list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Normalize REPL search responses before table output**\n\nThe REPL `search` handler assumes `search_blocks` returns a list, but SiYuan commonly returns a dict containing a `blocks` array (which the one-shot `search` command already normalizes). If the dict form is returned, iterating `results` yields string keys and `r.get(...)` crashes, so search in REPL breaks for real API responses.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,692 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = cmd.strip().split()\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ if json_mode:\n+ click.echo(json.dumps(docs, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in docs])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(tree, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Title\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"title\", \"\"), t.get(\"path\", \"\")]\n+ for t in tree])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\" and len(parts) >= 4:\n+ result = client.insert_block(\"markdown\", parts[3], previous_id=parts[2] if len(parts) > 2 else \"\")\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ results = client.search_blocks(query)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in results])","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Report live connectivity in status output**\n\nUse a live connectivity value in `status` instead of `session.state.connected`. That session field is initialized to `False` and is never updated anywhere in this commit, so `status` reports `connected: false` even after successfully calling `get_version()`, which makes machine-readable status output inaccurate.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,692 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = cmd.strip().split()\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ if json_mode:\n+ click.echo(json.dumps(docs, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in docs])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(tree, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Title\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"title\", \"\"), t.get(\"path\", \"\")]\n+ for t in tree])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\" and len(parts) >= 4:\n+ result = client.insert_block(\"markdown\", parts[3], previous_id=parts[2] if len(parts) > 2 else \"\")\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ results = client.search_blocks(query)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in results])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ ctx.session.update(current_notebook_id=notebook_id)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {notebook_id}\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\"\"\"\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ items = tree.get(\"tree\", []) if isinstance(tree, dict) else tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in items:\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('title', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\")\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str, previous: str, parent: str, data_type: str):\n+ \"\"\"Insert a block.\"\"\"\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str, data_type: str):\n+ \"\"\"Update a block's content.\"\"\"\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ siyuan_ver = ctx.client.get_version()\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": state.connected,","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Parse REPL input with shell-style tokenization**\n\nThe REPL parser uses `cmd.strip().split()`, which loses quoting and breaks multi-word arguments. As a result, commands that rely on positional tokens (for example `block insert`, `block update`, and `doc create --md`) only receive a fragment of the intended payload or include literal quote characters, so markdown with spaces is inserted/updated incorrectly. This is a functional data-loss bug for normal note content entered in REPL.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,696 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = cmd.strip().split()","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Catch request timeouts and transport errors uniformly**\n\n`_post` only converts `requests.ConnectionError` into `SiYuanClientError`, but other common transport failures (for example timeouts/read errors/SSL errors) bubble up as raw exceptions. In those cases callers that handle `SiYuanClientError` won't catch the failure, so users get unhandled errors instead of the intended CLI error message path.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,284 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))\n+ return SiYuanConfig(\n+ host=data.get(\"host\", \"127.0.0.1\"),\n+ port=data.get(\"port\", 6806),\n+ token=data.get(\"token\", \"\"),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Normalize createNotebook payload before returning**\n\n`create_notebook()` currently returns the raw `data` object from `/api/notebook/createNotebook`, but SiYuan’s API shape is `{\"notebook\": {...}}` for that endpoint. Downstream code paths (`notebook create` and REPL notebook creation) read `nb[\"id\"]`/`nb[\"name\"]` directly, so real API responses trigger a `KeyError` instead of creating and reporting the notebook.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,292 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))\n+ return SiYuanConfig(\n+ host=data.get(\"host\", \"127.0.0.1\"),\n+ port=data.get(\"port\", 6806),\n+ token=data.get(\"token\", \"\"),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/createNotebook\", {\"name\": name})","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Require an anchor for block insert**\n\nThis command allows `block insert <data>` with both `--parent` and `--previous` empty, then calls `insertBlock` without any position anchor. The SiYuan API requires at least one of `nextID`, `previousID`, or `parentID` for `/api/block/insertBlock`, so the default invocation path fails at runtime unless users discover and pass extra flags.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,697 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ items = tree.get(\"tree\", []) if isinstance(tree, dict) else tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Title\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"title\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\" and len(parts) >= 4:\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ ctx.session.update(current_notebook_id=notebook_id)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {notebook_id}\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\"\"\"\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ items = tree.get(\"tree\", []) if isinstance(tree, dict) else tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in items:\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('title', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\")\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str, previous: str, parent: str, data_type: str):\n+ \"\"\"Insert a block.\"\"\"\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous)","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Persist REPL session state before exit**\n\nThe REPL loop breaks immediately on `quit/exit/q` without flushing the session, but multiple REPL commands call `get_session().update(...)` and only mark the state dirty. Because `SessionManager` persists changes only on `flush()`/`save()`, notebook/document context changes made during a REPL session are lost after exiting and are not available in the next run.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,703 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ break","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Handle malformed config JSON without crashing**\n\n`load_config()` parses `~/.siyuan-cli.json` with `json.loads(...)` and does not catch decode/read errors. If a user has an invalid or partially written config file, every CLI command crashes during startup instead of reporting a friendly config error or falling back to env/defaults, which effectively bricks the CLI until the file is manually fixed.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,295 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Flush the REPL session via the context object**\n\nWhen a user exits the REPL with `quit`, `exit`, or `q`, `ctx` is the Click context and does not have a `session` attribute; the session manager is available as the local `session` variable or `ctx.obj.session`. Because this branch is outside the command handler's `try`, normal REPL exit raises `AttributeError` instead of saving dirty state and printing the goodbye message.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,704 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.session.flush()","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Fall back to environment after invalid config**\n\nThe current malformed-config handler avoids the JSON crash, but it sets `data = {}` and then immediately returns default host/port/token values from the file branch, so a user with a bad or partially written `~/.siyuan-cli.json` cannot recover by setting `SIYUAN_TOKEN`/`SIYUAN_HOST` as documented. In that scenario the CLI silently drops the env credentials and continues unauthenticated/defaulted until the file is manually fixed.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,298 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = {}","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Convert API errors before leaving one-shot commands**\n\nWhen a one-shot command hits a normal SiYuan API failure such as a bad token or non-zero API `code`, `_post()` raises `SiYuanClientError`, but this command path has no handler and `SiYuanClientError` is not a Click exception. I verified the one-shot path with `CliRunner`: `notebook list` exits with the raw exception and no CLI error output, so users running documented commands get a traceback instead of the intended friendly error handling that the REPL already provides.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,704 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ items = tree.get(\"tree\", []) if isinstance(tree, dict) else tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Title\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"title\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Read doc-tree entries from the files key**\n\nWhen SiYuan returns the documented `/api/filetree/listDocTree` shape, `data` is a dict containing a `files` array, not a `tree` array; I checked the filetree/listDocTree API docs/source links. In that common response path this line turns the result into `[]`, so `cli-anything-siyuan doc tree <notebook>` reports an empty tree even when documents exist. The REPL branch has the same normalization pattern, so both paths should read `files` (and render the returned `name` field rather than `title`).\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,715 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ items = tree.get(\"tree\", []) if isinstance(tree, dict) else tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Title\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"title\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ ctx.session.update(current_notebook_id=notebook_id)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {notebook_id}\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\"\"\"\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ items = tree.get(\"tree\", []) if isinstance(tree, dict) else tree","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Request the uncapped tag list**\n\nWhen a workspace has more tags than SiYuan's `Conf.FileTree.MaxListCount`, `/api/tag/getTag` stops building the response unless the request includes `ignoreMaxListHint: true`; this makes both `tag list` and `--json tag list` silently omit the remaining tags even though the command is documented as listing all tags. Pass that flag here before rendering the result so large/tag-heavy workspaces are complete.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,300 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ return SiYuanConfig(\n+ host=data.get(\"host\", \"127.0.0.1\"),\n+ port=data.get(\"port\", 6806),\n+ token=data.get(\"token\", \"\"),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"keyword\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/searchTag\", {\"tag\": tag})\n+\n+ def find_replace(self, keyword: str, replacement: str, notebook_id: str = \"\", path: str = \"\", max_count: int = 0) -> int:\n+ data = self._post(\"/api/search/findReplace\", {\n+ \"keyword\": keyword, \"replacement\": replacement,\n+ \"notebookID\": notebook_id, \"path\": path, \"maxCount\": max_count,\n+ })\n+ return data.get(\"count\", 0)\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {})","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Clear or refresh the notebook name when opening**\n\nWhen a session already has `current_notebook_name` set and the user runs `notebook open <different-id>`, this only changes the ID and flushes the stale name back to disk. The `status` command and REPL prompt render `current_notebook_name`, so they continue to report the previous notebook after a successful open; fetch the notebook name or clear it when updating the ID.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,719 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ items = tree.get(\"files\", []) if isinstance(tree, dict) else tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ ctx.session.update(current_notebook_id=notebook_id)","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Traverse nested tags in text output**\n\nIn workspaces that use hierarchical tags, SiYuan returns child tags under each tag's `children` field, but this text output loop only prints the top-level entries. That makes `tag list` omit nested tags even though `--json tag list` includes them, contradicting the command's \"List all tags\" behavior for users who rely on the human-readable output.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,719 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ items = tree.get(\"files\", []) if isinstance(tree, dict) else tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ ctx.session.update(current_notebook_id=notebook_id)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {notebook_id}\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\"\"\"\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ items = tree.get(\"files\", []) if isinstance(tree, dict) else tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in items:\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = click.get_text_stream(\"stdin\").read()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = click.get_text_stream(\"stdin\").read()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags.\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ for t in tags:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Point dev fallback at an executable module**\n\nWhen the console script is not installed, this fallback resolves `cli-anything-siyuan` to `python -m cli_anything.siyuan.siyuan_cli`, but `siyuan_cli.py` only defines the Click group and has no `if __name__ == \"__main__\": cli()` invocation; in a dev environment with dependencies installed the subprocess exits without running Click, so the E2E help/version tests assert against empty stdout. Use the package module that has `__main__.py` (`cli_anything.siyuan`) or add the missing module entrypoint.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py","hunk":"@@ -0,0 +1,122 @@\n+\"\"\"E2E tests for cli-anything-siyuan.\n+\n+Requires a running SiYuan instance at http://127.0.0.1:6806.\n+Set SIYUAN_TOKEN env var if authentication is enabled.\n+\"\"\"\n+\n+import json\n+import os\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.siyuan.core.client import SiYuanClient, SiYuanClientError, load_config\n+\n+\n+def _resolve_cli(name: str) -> list[str]:\n+ \"\"\"Resolve installed CLI command; falls back to python -m for dev.\"\"\"\n+ import shutil\n+ force = os.environ.get(\"CLI_ANYTHING_FORCE_INSTALLED\", \"\").strip() == \"1\"\n+ path = shutil.which(name)\n+ if path:\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+ if force:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ module = name.replace(\"cli-anything-\", \"cli_anything.\") + \".\" + name.split(\"-\")[-1] + \"_cli\"\n+ print(f\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py b/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2efee700a\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py\n@@ -0,0 +1,122 @@\n+\"\"\"E2E tests for cli-anything-siyuan.\n+\n+Requires a running SiYuan instance at http://127.0.0.1:6806.\n+Set SIYUAN_TOKEN env var if authentication is enabled.\n+\"\"\"\n+\n+import json\n+import os\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.siyuan.core.client import SiYuanClient, SiYuanClientError, load_config\n+\n+\n+def _resolve_cli(name: str) -> list[str]:\n+ \"\"\"Resolve installed CLI command; falls back to python -m for dev.\"\"\"\n+ import shutil\n+ force = os.environ.get(\"CLI_ANYTHING_FORCE_INSTALLED\", \"\").strip() == \"1\"\n+ path = shutil.which(name)\n+ if path:\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+ if force:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ module = name.replace(\"cli-anything-\", \"cli_anything.\") # e.g. cli_anything.siyuan (has __main__.py)\n+ print(f\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+\n+CLI_BASE = _resolve_cli(\"cli-anything-siyuan\")\n+\n+\n+# ── Fixtures ───────────────────────────────────────────────────────────\n+\n+@pytest.fixture(scope=\"session\")\n+def client() -> SiYuanClient:\n+ \"\"\"Create a client connected to the real SiYuan instance.\"\"\"\n+ config = load_config()\n+ c = SiYuanClient(config)\n+ if not c.ping():\n+ pytest.skip(\"SiYuan is not running — E2E tests require a running instance\")\n+ return c\n+\n+\n+@pytest.fixture\n+def tmp_dir() -> Path:\n+ \"\"\"Create a temporary directory for test artifacts.\"\"\"\n+ import tempfile\n+ path = Path(tempfile.mkdtemp(prefix=\"siyuan_e2e_\"))\n+ yield path\n+ import shutil\n+ shutil.rmtree(path, ignore_errors=True)\n+\n+\n+class TestCLISubprocess:\n+ CLI_BASE = CLI_BASE\n+\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess:\n+ return subprocess.run(\n+ self.CLI_BASE + args,\n+ capture_output=True, text=True, check=check,\n+ )\n+\n+ def test_help(self):\n+ \"\"\"--help returns 0 and shows usage.\"\"\"\n+ result = self._run([\"--help\"])\n+ assert result.returncode == 0\n+ assert \"Usage:\" in result.stdout\n+ print(f\"\\n --help: OK ({len(result.stdout)} chars)\")\n+\n+ def test_version_json(self, client: SiYuanClient):\n+ \"\"\"--json version returns valid JSON with version string.\"\"\"\n+ result = self._run([\"--json\", \"version\"])\n+ assert result.returncode == 0\n+ data = json.loads(result.stdout)\n+ assert \"version\" in data\n+ assert data[\"version\"]\n+ print(f\"\\n SiYuan version: {data['version']}\")\n+\n+ def test_status_json(self, client: SiYuanClient):\n+ \"\"\"--json status returns valid JSON with connection info.\"\"\"\n+ result = self._run([\"--json\", \"status\"])\n+ assert result.returncode == 0\n+ data = json.loads(result.stdout)\n+ assert \"siyuan_version\" in data\n+ assert data[\"siyuan_version\"]\n+ print(f\"\\n Status: connected to SiYuan v{data['siyuan_version']}\")\n+\n+\n+class TestBackendE2E:\n+ \"\"\"Tests that hit the real SiYuan API via Python client.\"\"\"\n+\n+ def test_get_version(self, client: SiYuanClient):\n+ \"\"\"Get the SiYuan kernel version from a running instance.\"\"\"\n+ ver = client.get_version()\n+ assert ver\n+ assert isinstance(ver, str)\n+ assert len(ver) > 0\n+ print(f\"\\n SiYuan kernel version: {ver}\")\n+\n+ def test_list_notebooks(self, client: SiYuanClient):\n+ \"\"\"List all notebooks from the running instance.\"\"\"\n+ notebooks = client.list_notebooks()\n+ assert isinstance(notebooks, list)\n+ if notebooks:\n+ nb = notebooks[0]\n+ assert \"id\" in nb\n+ assert \"name\" in nb\n+ print(f\"\\n Notebooks found: {len(notebooks)}\")\n+ print(f\" First: {nb['name']} ({nb['id']})\")\n+ else:\n+ print(\"\\n No notebooks found (empty instance)\")\n+\n+ def test_get_current_time(self, client: SiYuanClient):\n+ \"\"\"Get current time from server.\"\"\"\n+ t = client.get_current_time()\n+ assert t > 0\n+ assert isinstance(t, int)\n+ print(f\"\\n Server time (ts): {t}\")\n"},{"comment":"**<sub><sub></sub></sub> Put Markdown content behind --md in the skill example**\n\nWhen agents follow this skill example to create a document with initial content, Click receives the Markdown as a third positional argument even though `doc create` only declares `notebook_id` and `path` plus the `--md` option, so the command exits with an unexpected-extra-argument error before creating anything. Use the documented shape, e.g. `doc create nb1 /projects/new --md ...`, so the installed skill does not teach a failing workflow.\n\nUseful? React with 👍 / 👎.","path":"skills/cli-anything-siyuan/SKILL.md","hunk":"@@ -0,0 +1,93 @@\n+---\n+name: \"cli-anything-siyuan\"\n+description: SiYuan (思源笔记) CLI — manage notebooks, documents, blocks, and search your knowledge base from the terminal.\n+---\n+\n+# cli-anything-siyuan\n+\n+CLI harness for [SiYuan](https://github.com/siyuan-note/siyuan) (思源笔记),\n+a local-first knowledge management and note-taking application.\n+\n+This CLI connects to a running SiYuan kernel via its HTTP API\n+(`http://127.0.0.1:6806`) and provides structured access to notebooks,\n+documents, blocks, search, and export.\n+\n+## Prerequisites\n+\n+- SiYuan must be running (Settings → About shows the API token)\n+- Python 3.10+\n+- Install: `pip install cli-anything-siyuan` or `pip install -e .` from agent-harness/\n+\n+## Command Groups\n+\n+### notebook — Notebook management\n+| Subcommand | Description |\n+|------------|-------------|\n+| `list` | List all notebooks |\n+| `create <name>` | Create a new notebook |\n+| `rename <id> <name>` | Rename a notebook |\n+| `remove <id>` | Delete a notebook |\n+| `open <id>` | Open a notebook |\n+\n+### doc — Document management\n+| Subcommand | Description |\n+|------------|-------------|\n+| `create <notebook> <path> [--md \"content\"]` | Create a document |\n+| `list <notebook> [path]` | List documents |\n+| `tree <notebook> [--path / --depth]` | Show doc tree |\n+| `get <id>` | Get document path by ID |\n+| `rename <id> <title>` | Rename a document |\n+| `remove <id>` | Delete a document |\n+\n+### block — Block operations\n+| Subcommand | Description |\n+|------------|-------------|\n+| `insert <data> [--previous / --parent]` | Insert a block |\n+| `update <id> <data>` | Update a block |\n+| `delete <id>` | Delete a block |\n+| `get <id>` | Get block kramdown source |\n+| `children <id>` | Get child blocks |\n+\n+### Other commands\n+| Command | Description |\n+|---------|-------------|\n+| `sql <stmt>` | Execute SQL on the block database |\n+| `search <query>` | Full-text search across blocks |\n+| `export md <doc-id>` | Export document as Markdown |\n+| `tag list` | List all tags |\n+| `version` | Show SiYuan kernel version |\n+| `status` | Show connection and session status |\n+| `repl` | Start interactive REPL |\n+\n+## Agent Guidance\n+\n+- Always use `--json` for machine-readable output\n+- Power search: use `sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%'\"` for SQL-level access\n+- Document IDs look like `20210817205410-2kvfpfn` (timestamp-based)\n+- API token can be found in SiYuan Settings → About\n+- Connection defaults: `http://127.0.0.1:6806`\n+\n+## Examples\n+\n+```bash\n+# List notebooks (JSON)\n+cli-anything-siyuan --json notebook list\n+\n+# Create a document with Markdown\n+cli-anything-siyuan doc create nb1 /projects/new \"## Title\\n\\nContent\"","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/skills/cli-anything-siyuan/SKILL.md b/skills/cli-anything-siyuan/SKILL.md\nnew file mode 100644\nindex 000000000..9c594d521\n--- /dev/null\n+++ b/skills/cli-anything-siyuan/SKILL.md\n@@ -0,0 +1,106 @@\n+---\n+name: \"cli-anything-siyuan\"\n+description: SiYuan (思源笔记) CLI — manage notebooks, documents, blocks, and search your knowledge base from the terminal.\n+---\n+\n+# cli-anything-siyuan\n+\n+CLI harness for [SiYuan](https://github.com/siyuan-note/siyuan) (思源笔记),\n+a local-first knowledge management and note-taking application.\n+\n+This CLI connects to a running SiYuan kernel via its HTTP API\n+(`http://127.0.0.1:6806`) and provides structured access to notebooks,\n+documents, blocks, search, and export.\n+\n+## Prerequisites\n+\n+- SiYuan must be running (Settings → About shows the API token)\n+- Python 3.10+\n+- Install: `pip install cli-anything-siyuan` or `pip install -e .` from agent-harness/\n+\n+## Command Groups\n+\n+### notebook — Notebook management\n+| Subcommand | Description |\n+|------------|-------------|\n+| `list` | List all notebooks |\n+| `create <name>` | Create a new notebook |\n+| `rename <id> <name>` | Rename a notebook |\n+| `remove <id>` | Delete a notebook |\n+| `open <id>` | Open a notebook |\n+\n+### doc — Document management\n+| Subcommand | Description |\n+|------------|-------------|\n+| `create <notebook> <path> [--md \"content\"]` | Create a document |\n+| `list <notebook> [path]` | List documents |\n+| `tree <notebook> [--path / --depth]` | Show doc tree |\n+| `get <id>` | Get document path by ID |\n+| `rename <id> <title>` | Rename a document |\n+| `remove <id>` | Delete a document |\n+\n+### block — Block operations\n+| Subcommand | Description |\n+|------------|-------------|\n+| `insert <data> [--previous / --parent]` | Insert a block |\n+| `update <id> <data>` | Update a block |\n+| `delete <id>` | Delete a block |\n+| `get <id>` | Get block kramdown source |\n+| `children <id>` | Get child blocks |\n+\n+### Other commands\n+| Command | Description |\n+|---------|-------------|\n+| `sql <stmt>` | Execute SQL on the block database |\n+| `search <query>` | Full-text search across blocks |\n+| `export md <doc-id>` | Export document as Markdown |\n+| `tag list` | List all tags |\n+| `version` | Show SiYuan kernel version |\n+| `status` | Show connection and session status |\n+| `repl` | Start interactive REPL |\n+\n+## Agent Guidance\n+\n+- Always use `--json` for machine-readable output\n+- Power search: use `sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%'\"` for SQL-level access\n+- Document IDs look like `20210817205410-2kvfpfn` (timestamp-based)\n+- API token can be found in SiYuan Settings → About\n+- Connection defaults: `http://127.0.0.1:6806`\n+\n+## Examples\n+\n+```bash\n+# List notebooks (JSON)\n+cli-anything-siyuan --json notebook list\n+\n+# Create a document with Markdown (--md flag, watch shell escaping)\n+cli-anything-siyuan doc create nb1 /projects/new --md \"## Title\\n\\nContent\"\n+\n+# Create a document — pipe Markdown via stdin (avoids shell escaping)\n+# PowerShell here-string (literal, no escaping needed):\n+@'\n+## Title\n+Content with `backticks` and (parentheses) and \"quotes\"\n+'@ | cli-anything-siyuan doc create nb1 /projects/new --md -\n+\n+# Bash heredoc:\n+# cat <<'EOF' | cli-anything-siyuan doc create nb1 /projects/new --md -\n+# ## Title\n+# Content with `backticks` and (parentheses)\n+# EOF\n+\n+# SQL search\n+cli-anything-siyuan sql \"SELECT id, content FROM blocks WHERE content LIKE '%meeting%' LIMIT 5\"\n+\n+# Export\n+cli-anything-siyuan export md doc123\n+\n+# Enter REPL\n+cli-anything-siyuan\n+```\n+\n+## Error Handling\n+\n+- Connection errors: check that SiYuan is running and the API token is correct\n+- API errors: returned as `{\"code\": N, \"msg\": \"...\"}` — check the message field\n+- Auth errors: verify the token in `~/.siyuan-cli.json` or `SIYUAN_TOKEN` env var\n"},{"comment":"**<sub><sub></sub></sub> Honor environment overrides when config exists**\n\nWhen a valid `~/.siyuan-cli.json` exists, this early return ignores `SIYUAN_HOST`, `SIYUAN_PORT`, and `SIYUAN_TOKEN` entirely. In environments where users rely on the documented env vars to override a stale local config or to supply a token that is omitted from the file, the CLI continues with the file/default credentials and fails to authenticate; read the file as defaults but apply env values before returning.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,300 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ return SiYuanConfig(\n+ host=data.get(\"host\", \"127.0.0.1\"),\n+ port=data.get(\"port\", 6806),\n+ token=data.get(\"token\", \"\"),\n+ )","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Avoid blocking empty doc creation on stdin**\n\nWhen users follow the documented `doc create <notebook-id> <path>` form from an interactive shell and omit `--md`, this branch reads from stdin and waits for EOF instead of creating an empty document. SiYuan accepts an empty `markdown` value for this API, so only the explicit `--md -` case should consume stdin; otherwise the basic create command can appear hung.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,743 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\n+ if hasattr(sys.stdout, 'reconfigure'):\n+ sys.stdout.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ items = tree.get(\"files\", []) if isinstance(tree, dict) else tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' or omit to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if not md or md == \"-\":\n+ md = click.get_text_stream(\"stdin\").read()","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Support tree-shaped doc tree responses**\n\nWhen SiYuan returns `/api/filetree/listDocTree` data under the `tree` key, this normalization drops the entire result because it only accepts `files` from dict responses. I checked the SiYuan v3.4.2 kernel `api/filetree.go`, where `listDocTree` sets `ret.Data = {\"tree\": doctree}`, so `cli-anything-siyuan doc tree ...` will print no documents for those kernels even though the API succeeded; please accept both `files` and `tree` before falling back to an empty list.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,758 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ items = tree.get(\"files\", []) if isinstance(tree, dict) else tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' or omit to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if not md or md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ items = tree.get(\"files\", []) if isinstance(tree, dict) else tree","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Traverse doc-tree children before rendering**\n\nWhen `/api/filetree/listDocTree` returns the tree-shaped response, nested documents are stored under each node's `children` field, but this text renderer only iterates the top-level `items`. In any notebook with documents inside subdocuments/folders, `doc tree <notebook>` omits all descendants even though the command is meant to show the full document tree; flatten or recursively print `children` here (and in the REPL path) before rendering.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,764 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Global state ───────────────────────────────────────────────────────\n+\n+_config: SiYuanConfig | None = None\n+_client: SiYuanClient | None = None\n+_session_mgr: SessionManager | None = None\n+\n+\n+def get_client() -> SiYuanClient:\n+ global _client, _config\n+ if _client is None:\n+ _config = load_config()\n+ _client = SiYuanClient(_config)\n+ return _client\n+\n+\n+def get_session() -> SessionManager:\n+ global _session_mgr\n+ if _session_mgr is None:\n+ _session_mgr = SessionManager()\n+ _session_mgr.load()\n+ return _session_mgr\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = get_client()\n+ self.session = get_session()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ global _config, _client\n+ if host or port or token or config_path:\n+ cfg = load_config(config_path or None)\n+ _config = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ _client = SiYuanClient(_config)\n+ ctx.obj = SiYuanContext(json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not get_client().ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block\",\n+ \"block update <id> <data>\": \"Update a block\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ try:\n+ kernel_version = get_client().get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ session = get_session()\n+ state = session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ ctx.obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ skin.status_block({\n+ \"Connected\": str(state.connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _handle_repl_command(skin, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\n+ \"\"\"Parse and execute a REPL command.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ client = get_client()\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ # notebook commands\n+ if parts[0] == \"notebook\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ get_session().update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+ # doc commands\n+ elif parts[0] == \"doc\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in items])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+ # block commands\n+ elif parts[0] == \"block\":\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ result = client.insert_block(\"markdown\", parts[3], parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ client.prepend_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ client.append_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ client.update_block(\"markdown\", parts[3], parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+ # sql command\n+ elif parts[0] == \"sql\" and len(parts) >= 2:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+ # search command\n+ elif parts[0] == \"search\" and len(parts) >= 2:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+ # export command\n+ elif parts[0] == \"export\" and len(parts) >= 3:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in items:\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"},{"comment":"**<sub><sub></sub></sub> Send the tag query as k**\n\nWhen callers use this client helper, SiYuan's `searchTag` handler reads the query from `arg[\"k\"]` and returns a dict containing `tags`; sending `tag` leaves the required key unset, so real kernels fail before searching instead of returning matching tags. Use the `k` payload key and unwrap the returned `tags` array.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,301 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"keyword\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/searchTag\", {\"tag\": tag})","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Use SiYuan's findReplace payload shape**\n\nWhen this helper is used, SiYuan's `/api/search/findReplace` handler expects `k`, `r`, and an `ids` array (plus the usual search filters), and successful calls return null data rather than a count object. This payload sends unrelated key names and then calls `.get()` on the null success data, so the method cannot perform a normal find/replace call against a real kernel.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,301 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"keyword\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/searchTag\", {\"tag\": tag})\n+\n+ def find_replace(self, keyword: str, replacement: str, notebook_id: str = \"\", path: str = \"\", max_count: int = 0) -> int:\n+ data = self._post(\"/api/search/findReplace\", {\n+ \"keyword\": keyword, \"replacement\": replacement,\n+ \"notebookID\": notebook_id, \"path\": path, \"maxCount\": max_count,\n+ })\n+ return data.get(\"count\", 0)","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Request uncapped document listings**\n\nWhen a path contains more children than SiYuan's `FileTree.MaxListCount`, `/api/filetree/listDocsByPath` defaults to that cap unless `maxListCount` is supplied (with `0`/negative disabling the cap). Because this helper sends only `notebook` and `path`, both `doc list` and the REPL `doc list` can silently render only the first capped subset while the command is described as listing the directory; pass `maxListCount: 0` or expose a limit option for the list-all behavior.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,305 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\"notebook\": notebook_id, \"path\": path})","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Send the document search term as k**\n\nWhen this public helper is used against SiYuan's `/api/filetree/searchDocs`, the kernel reads the search string from `arg[\"k\"]`; sending `keyword` leaves the required key absent, so real kernels fail the request instead of returning matching documents. Use the payload key `k` here to make `search_docs()` usable.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/core/client.py","hunk":"@@ -0,0 +1,305 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"keyword\": keyword})","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\nnew file mode 100644\nindex 000000000..f274d8810\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\n@@ -0,0 +1,307 @@\n+\"\"\"SiYuan HTTP API client.\n+\n+Handles connection, authentication, and request/response to the SiYuan kernel.\n+\"\"\"\n+\n+import json\n+import os\n+from dataclasses import dataclass\n+from pathlib import Path\n+from typing import Any\n+\n+import requests\n+\n+\n+@dataclass(frozen=True)\n+class SiYuanConfig:\n+ host: str = \"127.0.0.1\"\n+ port: int = 6806\n+ token: str = \"\"\n+\n+ @property\n+ def base_url(self) -> str:\n+ return f\"http://{self.host}:{self.port}\"\n+\n+\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\n+ \"\"\"Load SiYuan connection config from file or environment.\n+\n+ Priority: explicit path -> env vars -> defaults.\n+ Config file is JSON: {\"host\": \"...\", \"port\": 6806, \"token\": \"...\"}\n+ \"\"\"\n+ if config_path:\n+ config_file = Path(config_path)\n+ else:\n+ config_file = Path.home() / \".siyuan-cli.json\"\n+\n+ if config_file.is_file():\n+ try:\n+ data = json.loads(config_file.read_text(encoding=\"utf-8-sig\"))\n+ except (json.JSONDecodeError, OSError):\n+ data = None\n+\n+ if data is not None:\n+ # File values as base, env vars override\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", data.get(\"host\", \"127.0.0.1\")),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", data.get(\"port\", 6806))),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", data.get(\"token\", \"\")),\n+ )\n+\n+ return SiYuanConfig(\n+ host=os.environ.get(\"SIYUAN_HOST\", \"127.0.0.1\"),\n+ port=int(os.environ.get(\"SIYUAN_PORT\", \"6806\")),\n+ token=os.environ.get(\"SIYUAN_TOKEN\", \"\"),\n+ )\n+\n+\n+class SiYuanClientError(Exception):\n+ \"\"\"Raised when the SiYuan API returns an error.\"\"\"\n+\n+\n+class SiYuanClient:\n+ \"\"\"HTTP client for the SiYuan kernel API.\"\"\"\n+\n+ def __init__(self, config: SiYuanConfig | None = None):\n+ self.config = config or load_config()\n+ self._session = requests.Session()\n+ self._session.trust_env = False\n+ if self.config.token:\n+ self._session.headers[\"Authorization\"] = f\"Token {self.config.token}\"\n+ self._session.headers[\"Content-Type\"] = \"application/json\"\n+\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\n+ \"\"\"Make a POST request to the SiYuan API.\"\"\"\n+ url = f\"{self.config.base_url}{endpoint}\"\n+ try:\n+ resp = self._session.post(url, json=data or {}, timeout=30)\n+ except requests.ConnectionError as e:\n+ raise SiYuanClientError(\n+ f\"Cannot connect to SiYuan at {self.config.base_url}. \"\n+ f\"Is SiYuan running? ({e})\"\n+ ) from e\n+ except requests.Timeout as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan timed out after 30s ({e})\"\n+ ) from e\n+ except requests.RequestException as e:\n+ raise SiYuanClientError(\n+ f\"Request to SiYuan failed: {e}\"\n+ ) from e\n+\n+ if resp.status_code != 200:\n+ raise SiYuanClientError(\n+ f\"API returned status {resp.status_code}: {resp.text[:200]}\"\n+ )\n+\n+ body = resp.json()\n+ if body.get(\"code\", 0) != 0:\n+ raise SiYuanClientError(\n+ f\"API error: {body.get('msg', 'unknown error')}\"\n+ )\n+ return body.get(\"data\")\n+\n+ def ping(self) -> bool:\n+ \"\"\"Check if SiYuan kernel is reachable.\"\"\"\n+ try:\n+ return self._post(\"/api/system/version\") is not None\n+ except SiYuanClientError:\n+ return False\n+\n+ # ── Notebook API ───────────────────────────────────────────────────\n+\n+ def list_notebooks(self) -> list[dict[str, Any]]:\n+ \"\"\"List all notebooks.\"\"\"\n+ data = self._post(\"/api/notebook/lsNotebooks\")\n+ return data.get(\"notebooks\", [])\n+\n+ def open_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/openNotebook\", {\"notebook\": notebook_id})\n+\n+ def close_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/closeNotebook\", {\"notebook\": notebook_id})\n+\n+ def create_notebook(self, name: str) -> dict[str, Any]:\n+ data = self._post(\"/api/notebook/createNotebook\", {\"name\": name})\n+ if isinstance(data, dict) and \"notebook\" in data:\n+ return data[\"notebook\"]\n+ return data\n+\n+ def remove_notebook(self, notebook_id: str) -> None:\n+ self._post(\"/api/notebook/removeNotebook\", {\"notebook\": notebook_id})\n+\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\n+ self._post(\"/api/notebook/renameNotebook\", {\"notebook\": notebook_id, \"name\": name})\n+\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookConf\", {\"notebook\": notebook_id})\n+\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/setNotebookConf\", {\"notebook\": notebook_id, \"conf\": conf})\n+\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\n+ self._post(\"/api/notebook/setNotebookIcon\", {\"notebook\": notebook_id, \"icon\": icon})\n+\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/notebook/getNotebookInfo\", {\"notebook\": notebook_id})\n+\n+ # ── Document / Filetree API ────────────────────────────────────────\n+\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \"\") -> str:\n+ \"\"\"Create a document with Markdown content. Returns the doc ID.\"\"\"\n+ return self._post(\"/api/filetree/createDocWithMd\", {\n+ \"notebook\": notebook_id, \"path\": path, \"markdown\": markdown,\n+ })\n+\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDoc\", {\"notebook\": notebook_id, \"path\": path, \"title\": title})\n+\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\n+ self._post(\"/api/filetree/renameDocByID\", {\"id\": doc_id, \"title\": title})\n+\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\n+ self._post(\"/api/filetree/removeDoc\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def remove_doc_by_id(self, doc_id: str) -> None:\n+ self._post(\"/api/filetree/removeDocByID\", {\"id\": doc_id})\n+\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\n+ self._post(\"/api/filetree/moveDocs\", {\n+ \"fromPaths\": from_paths, \"toNotebook\": to_notebook, \"toPath\": to_path,\n+ })\n+\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\n+ self._post(\"/api/filetree/moveDocsByID\", {\"fromIDs\": from_ids, \"toID\": to_id})\n+\n+ def get_hpath_by_id(self, block_id: str) -> str:\n+ return self._post(\"/api/filetree/getHPathByID\", {\"id\": block_id})\n+\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/filetree/getPathByID\", {\"id\": block_id})\n+\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\n+ return self._post(\"/api/filetree/getIDsByHPath\", {\"notebook\": notebook_id, \"path\": path})\n+\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocsByPath\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxListCount\": 0,\n+ })\n+\n+ def list_doc_tree(self, notebook_id: str, path: str = \"/\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/listDocTree\", {\n+ \"notebook\": notebook_id, \"path\": path, \"maxDepth\": max_depth, \"sort\": sort,\n+ })\n+\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/filetree/searchDocs\", {\"k\": keyword})\n+\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\n+ return self._post(\"/api/filetree/createDailyNote\", {\"notebook\": notebook_id})\n+\n+ # ── Block API ──────────────────────────────────────────────────────\n+\n+ def insert_block(self, data_type: str, data: str,\n+ parent_id: str = \"\", previous_id: str = \"\", next_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"dataType\": data_type, \"data\": data}\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if next_id:\n+ params[\"nextID\"] = next_id\n+ return self._post(\"/api/block/insertBlock\", params)\n+\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/prependBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/appendBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"parentID\": parent_id,\n+ })\n+\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/updateBlock\", {\n+ \"dataType\": data_type, \"data\": data, \"id\": block_id,\n+ })\n+\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/deleteBlock\", {\"id\": block_id})\n+\n+ def move_block(self, block_id: str, previous_id: str = \"\", parent_id: str = \"\") -> list[dict[str, Any]]:\n+ params = {\"id\": block_id}\n+ if previous_id:\n+ params[\"previousID\"] = previous_id\n+ if parent_id:\n+ params[\"parentID\"] = parent_id\n+ return self._post(\"/api/block/moveBlock\", params)\n+\n+ def fold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/foldBlock\", {\"id\": block_id})\n+\n+ def unfold_block(self, block_id: str) -> None:\n+ self._post(\"/api/block/unfoldBlock\", {\"id\": block_id})\n+\n+ def get_block_kramdown(self, block_id: str) -> str:\n+ data = self._post(\"/api/block/getBlockKramdown\", {\"id\": block_id})\n+ return data.get(\"kramdown\", \"\")\n+\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/block/getChildBlocks\", {\"id\": block_id})\n+\n+ # ── Attribute API ──────────────────────────────────────────────────\n+\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\n+ self._post(\"/api/attr/setBlockAttrs\", {\"id\": block_id, \"attrs\": attrs})\n+\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\n+ return self._post(\"/api/attr/getBlockAttrs\", {\"id\": block_id})\n+\n+ # ── SQL Query API ──────────────────────────────────────────────────\n+\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/query/sql\", {\"stmt\": stmt})\n+\n+ # ── Search API ─────────────────────────────────────────────────────\n+\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\n+ return self._post(\"/api/search/fullTextSearchBlock\", {\"query\": query})\n+\n+ def search_tag(self, tag: str = \"\") -> list[str]:\n+ \"\"\"Search tags. Returns list of tag name strings.\"\"\"\n+ data = self._post(\"/api/search/searchTag\", {\"k\": tag})\n+ if isinstance(data, dict):\n+ return data.get(\"tags\", [])\n+ return data or []\n+\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\n+ \"\"\"Search and replace text in blocks by ID.\"\"\"\n+ self._post(\"/api/search/findReplace\", {\n+ \"k\": keyword, \"r\": replacement, \"ids\": ids,\n+ })\n+\n+ # ── Export API ─────────────────────────────────────────────────────\n+\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\n+ return self._post(\"/api/export/exportMdContent\", {\"id\": doc_id})\n+\n+ def export_resources(self, paths: list[str], name: str = \"\") -> str:\n+ params = {\"paths\": paths}\n+ if name:\n+ params[\"name\"] = name\n+ data = self._post(\"/api/export/exportResources\", params)\n+ return data.get(\"path\", \"\")\n+\n+ # ── Tag API ────────────────────────────────────────────────────────\n+\n+ def get_tags(self) -> list[dict[str, Any]]:\n+ return self._post(\"/api/tag/getTag\", {\"ignoreMaxListHint\": True})\n+\n+ # ── System API ─────────────────────────────────────────────────────\n+\n+ def get_version(self) -> str:\n+ return self._post(\"/api/system/version\")\n+\n+ def get_current_time(self) -> int:\n+ return self._post(\"/api/system/currentTime\")\n"},{"comment":"**<sub><sub></sub></sub> Handle prompt interrupts before leaving REPL**\n\nWhen users exit the REPL with Ctrl-D or Ctrl-C, `skin.get_input()`/`input()` raises `EOFError` or `KeyboardInterrupt` here before the later `quit` branch and before the `_dispatch_repl` `try`, so the loop unwinds without `obj.session.flush()` or the goodbye path. In sessions where commands updated the current notebook/document, those dirty session changes are lost and users see an exception-style exit; catch these prompt interrupts and route them through the same flush/break path as `quit`.\n\nUseful? React with 👍 / 👎.","path":"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py","hunk":"@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )","resolving_sha":"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae","resolving_diff":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\nnew file mode 100644\nindex 000000000..de4d1f345\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\n@@ -0,0 +1,802 @@\n+\"\"\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\n+\n+Connects to a running SiYuan kernel via its HTTP API and provides\n+commands for notebooks, documents, blocks, search, and export.\n+\"\"\"\n+\n+import json\n+import os\n+import shlex\n+import sys\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.siyuan.core.client import (\n+ SiYuanClient,\n+ SiYuanClientError,\n+ SiYuanConfig,\n+ load_config,\n+)\n+from cli_anything.siyuan.core.session import SessionManager\n+\n+\n+def _read_stdin() -> str:\n+ \"\"\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\n+\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\n+ Windows), which mangles CJK characters before Python sees them. Reading\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\n+ \"\"\"\n+ if sys.stdin.isatty():\n+ raise click.UsageError(\n+ \"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\"\n+ )\n+ raw = sys.stdin.buffer.read()\n+ try:\n+ return raw.decode('utf-8-sig')\n+ except UnicodeDecodeError:\n+ return raw.decode('utf-8-sig', errors='replace')\n+\n+\n+# ── Click context ─────────────────────────────────────────────────────\n+\n+class SiYuanContext:\n+ def __init__(self, client: SiYuanClient | None = None,\n+ session: SessionManager | None = None,\n+ json_output: bool = False):\n+ self.json_output = json_output\n+ self.client = client\n+ self.session = session or SessionManager()\n+\n+\n+class _CatchErrors(click.Group):\n+ \"\"\"Click Group that converts SiYuanClientError to clean CLI errors.\"\"\"\n+\n+ def invoke(self, ctx: click.Context) -> object:\n+ try:\n+ return super().invoke(ctx)\n+ except SiYuanClientError as e:\n+ click.echo(f\"Error: {e}\", err=True)\n+ sys.exit(1)\n+\n+\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output in JSON format\")\n+@click.option(\"--host\", default=\"\", help=\"SiYuan host (default: 127.0.0.1)\")\n+@click.option(\"--port\", default=0, type=int, help=\"SiYuan port (default: 6806)\")\n+@click.option(\"--token\", default=\"\", help=\"SiYuan API token\")\n+@click.option(\"--config\", \"config_path\", default=\"\", help=\"Config file path\")\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\n+ token: str, config_path: str):\n+ # Force UTF-8 output to handle CJK characters on Windows\n+ for stream in (sys.stdout, sys.stderr):\n+ if hasattr(stream, 'reconfigure'):\n+ stream.reconfigure(encoding='utf-8')\n+\n+ \"\"\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\n+\n+ Connects to a running SiYuan instance via its HTTP API.\n+ Default: http://127.0.0.1:6806\n+\n+ Configure connection via ~/.siyuan-cli.json, env vars\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\n+ \"\"\"\n+ session = SessionManager()\n+ session.load()\n+ cfg = load_config(config_path or None)\n+ if host or port or token:\n+ cfg = SiYuanConfig(\n+ host=host or cfg.host,\n+ port=port or cfg.port,\n+ token=token or cfg.token,\n+ )\n+ client = SiYuanClient(cfg)\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\n+\n+ if ctx.invoked_subcommand is None:\n+ if not client.ping():\n+ click.echo(\"Error: Cannot connect to SiYuan. Is it running?\", err=True)\n+ click.echo(\" Configure via: --host --port --token\", err=True)\n+ click.echo(\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\", err=True)\n+ sys.exit(1)\n+ ctx.invoke(repl)\n+\n+\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\n+ \"\"\"Recursively flatten a doc tree, setting depth on each entry.\n+\n+ Returns new dicts; does not mutate the originals.\n+ \"\"\"\n+ result: list[dict] = []\n+ for t in items:\n+ entry = {**t, \"depth\": depth}\n+ result.append(entry)\n+ children = t.get(\"children\")\n+ if children:\n+ result.extend(_walk_tree(children, depth + 1))\n+ return result\n+\n+\n+# ── REPL ───────────────────────────────────────────────────────────────\n+\n+def _build_repl_commands() -> dict[str, str]:\n+ return {\n+ \"notebook list\": \"List all notebooks\",\n+ \"notebook create <name>\": \"Create a notebook\",\n+ \"notebook rename <id> <name>\": \"Rename a notebook\",\n+ \"notebook remove <id>\": \"Remove a notebook\",\n+ \"doc create <notebook> <path>\": \"Create a document with optional --md content\",\n+ \"doc list <notebook> <path>\": \"List documents at path\",\n+ \"doc tree <notebook>\": \"List full document tree\",\n+ \"doc get <id>\": \"Get document info by ID\",\n+ \"block insert <parent> <data>\": \"Insert a block (use '-' for stdin)\",\n+ \"block update <id> <data>\": \"Update a block (use '-' for stdin)\",\n+ \"block delete <id>\": \"Delete a block\",\n+ \"block get <id>\": \"Get block kramdown source\",\n+ \"sql <stmt>\": \"Execute SQL query\",\n+ \"search <query>\": \"Full-text search\",\n+ \"export md <doc-id>\": \"Export doc as Markdown\",\n+ \"status\": \"Show connection and session status\",\n+ \"help\": \"Show this help\",\n+ \"quit\": \"Exit REPL\",\n+ }\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context):\n+ \"\"\"Start interactive REPL mode.\"\"\"\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\n+\n+ obj: SiYuanContext = ctx.obj\n+\n+ try:\n+ kernel_version = obj.client.get_version()\n+ except SiYuanClientError:\n+ kernel_version = \"?\"\n+ skin = ReplSkin(\"siyuan\", version=kernel_version)\n+ skin.print_banner()\n+\n+ pt_session = skin.create_prompt_session()\n+ commands = _build_repl_commands()\n+\n+ state = obj.session.state\n+\n+ while True:\n+ ctx_str = \"\"\n+ if state.current_notebook_name:\n+ ctx_str = state.current_notebook_name\n+ user_input = skin.get_input(\n+ pt_session,\n+ project_name=state.current_doc_path or \"\",\n+ modified=False,\n+ context=ctx_str,\n+ )\n+\n+ if not user_input:\n+ continue\n+\n+ if user_input in (\"quit\", \"exit\", \"q\"):\n+ obj.session.flush()\n+ break\n+\n+ if user_input == \"help\":\n+ skin.help(commands)\n+ continue\n+\n+ if user_input == \"status\":\n+ connected = obj.client.ping()\n+ skin.status_block({\n+ \"Connected\": str(connected),\n+ \"Notebook\": state.current_notebook_name or \"(none)\",\n+ \"Document\": state.current_doc_path or \"(none)\",\n+ }, title=\"Status\")\n+ continue\n+\n+ try:\n+ _dispatch_repl(skin, obj, user_input)\n+ except SiYuanClientError as e:\n+ skin.error(str(e))\n+ except Exception as e:\n+ skin.error(f\"Error: {e}\")\n+\n+ skin.print_goodbye()\n+\n+\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\n+ \"\"\"Parse REPL command and route to the appropriate handler.\"\"\"\n+ parts = shlex.split(cmd.strip())\n+ if not parts:\n+ return\n+\n+ json_mode = \"--json\" in parts\n+ parts = [p for p in parts if p != \"--json\"]\n+\n+ client = ctx.client\n+ session = ctx.session\n+\n+ command = parts[0]\n+ if command == \"notebook\":\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\n+ elif command == \"doc\":\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\n+ elif command == \"block\":\n+ _handle_block_repl(skin, client, parts, json_mode)\n+ elif command == \"sql\" and len(parts) >= 2:\n+ _handle_sql_repl(skin, client, parts, json_mode)\n+ elif command == \"search\" and len(parts) >= 2:\n+ _handle_search_repl(skin, client, parts, json_mode)\n+ elif command == \"export\":\n+ _handle_export_repl(skin, client, parts, json_mode)\n+ else:\n+ skin.error(f\"Unknown command: {parts[0]}\")\n+\n+\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\n+\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: notebook <list|create|rename|remove>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"list\":\n+ notebooks = client.list_notebooks()\n+ if json_mode:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Icon\", \"Closed\"],\n+ [[n[\"id\"], n[\"name\"], n.get(\"icon\", \"\"), str(n.get(\"closed\", \"\"))]\n+ for n in notebooks])\n+ elif sub == \"create\" and len(parts) >= 3:\n+ name = \" \".join(parts[2:])\n+ nb = client.create_notebook(name)\n+ session.update(current_notebook_id=nb[\"id\"], current_notebook_name=nb[\"name\"])\n+ client.open_notebook(nb[\"id\"])\n+ skin.success(f'Created notebook: {nb[\"name\"]} ({nb[\"id\"]})')\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_notebook(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_notebook(parts[2])\n+ skin.success(\"Removed\")\n+ else:\n+ skin.error(\"Invalid notebook command\")\n+\n+\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\n+ session: SessionManager, parts: list[str],\n+ json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: doc <create|list|tree|get|rename|remove|export>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"create\" and len(parts) >= 4:\n+ md = \"\"\n+ if \"--md\" in parts:\n+ idx = parts.index(\"--md\") + 1\n+ if idx < len(parts):\n+ md = parts[idx]\n+ parts = parts[:parts.index(\"--md\")]\n+ if md == \"-\":\n+ md = _read_stdin()\n+ nb_id = parts[2]\n+ doc_path = parts[3]\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\n+ if json_mode:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Created doc: {doc_id}\")\n+ elif sub == \"list\" and len(parts) >= 4:\n+ docs = client.list_docs_by_path(parts[2], parts[3])\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Type\"],\n+ [[d.get(\"id\", \"\"), d.get(\"name\", \"\"), d.get(\"type\", \"\")]\n+ for d in items])\n+ elif sub == \"tree\" and len(parts) >= 3:\n+ tree = client.list_doc_tree(parts[2])\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if json_mode:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Name\", \"Path\"],\n+ [[t.get(\"id\", \"\"), \" \" * t.get(\"depth\", 0) + t.get(\"name\", \"\"), t.get(\"path\", \"\")]\n+ for t in _walk_tree(items)])\n+ elif sub == \"get\" and len(parts) >= 3:\n+ hpath = client.get_hpath_by_id(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ skin.success(f\"Path: {hpath}\")\n+ elif sub == \"rename\" and len(parts) >= 4:\n+ client.rename_doc_by_id(parts[2], \" \".join(parts[3:]))\n+ skin.success(\"Renamed\")\n+ elif sub == \"remove\" and len(parts) >= 3:\n+ client.remove_doc_by_id(parts[2])\n+ skin.success(\"Removed\")\n+ elif sub == \"export\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Invalid doc command\")\n+\n+\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if len(parts) < 2:\n+ skin.error(\"Usage: block <insert|prepend|append|update|delete|get|child>\")\n+ return\n+ sub = parts[1]\n+ if sub == \"insert\":\n+ if len(parts) < 4:\n+ skin.error(\"Usage: block insert <parent_id> <data>\")\n+ return\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ result = client.insert_block(\"markdown\", data, parent_id=parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ skin.success(\"Block inserted\")\n+ elif sub == \"prepend\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.prepend_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block prepended\")\n+ elif sub == \"append\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.append_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block appended\")\n+ elif sub == \"update\" and len(parts) >= 4:\n+ data = parts[3]\n+ if data == \"-\":\n+ data = _read_stdin()\n+ client.update_block(\"markdown\", data, parts[2])\n+ skin.success(\"Block updated\")\n+ elif sub == \"delete\" and len(parts) >= 3:\n+ client.delete_block(parts[2])\n+ skin.success(\"Block deleted\")\n+ elif sub == \"get\" and len(parts) >= 3:\n+ kramdown = client.get_block_kramdown(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+ elif sub == \"child\" and len(parts) >= 3:\n+ children = client.get_child_blocks(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ skin.table([\"ID\", \"Type\", \"SubType\"],\n+ [[c.get(\"id\", \"\"), c.get(\"type\", \"\"), c.get(\"subType\", \"\")]\n+ for c in children])\n+ else:\n+ skin.error(\"Invalid block command\")\n+\n+\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ stmt = \" \".join(parts[1:])\n+ results = client.query_sql(stmt)\n+ if json_mode:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ skin.info(\"No results\")\n+ else:\n+ headers = list(results[0].keys())\n+ rows = [[str(r.get(h, \"\")) for h in headers] for r in results]\n+ skin.table(headers, rows)\n+\n+\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ query = \" \".join(parts[1:])\n+ data = client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if json_mode:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ skin.info(\"No results\")\n+ else:\n+ skin.table([\"ID\", \"Content\"],\n+ [[r.get(\"id\", \"\"), r.get(\"content\", \"\")[:80]] for r in blocks])\n+\n+\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\n+ parts: list[str], json_mode: bool) -> None:\n+ if parts[1] == \"md\" and len(parts) >= 3:\n+ md = client.export_md_content(parts[2])\n+ if json_mode:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ skin.section(md.get(\"hPath\", \"\"))\n+ click.echo(md.get(\"content\", \"\"))\n+ else:\n+ skin.error(\"Usage: export md <doc-id>\")\n+\n+\n+# ── Notebook commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def notebook():\n+ \"\"\"Manage notebooks (笔记本).\"\"\"\n+\n+\n+@notebook.command(\"list\")\n+@click.pass_obj\n+def notebook_list(ctx: SiYuanContext):\n+ \"\"\"List all notebooks.\"\"\"\n+ notebooks = ctx.client.list_notebooks()\n+ if ctx.json_output:\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Closed':<8}\")\n+ click.echo(\"-\" * 70)\n+ for nb in notebooks:\n+ click.echo(f\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\")\n+\n+\n+@notebook.command(\"create\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_create(ctx: SiYuanContext, name: str):\n+ \"\"\"Create a new notebook.\"\"\"\n+ nb = ctx.client.create_notebook(name)\n+ if ctx.json_output:\n+ click.echo(json.dumps(nb, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created notebook: {nb['name']} ({nb['id']})\")\n+\n+\n+@notebook.command(\"remove\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Remove a notebook by ID.\"\"\"\n+ ctx.client.remove_notebook(notebook_id)\n+ click.echo(f\"Removed notebook: {notebook_id}\")\n+\n+\n+@notebook.command(\"rename\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"name\")\n+@click.pass_obj\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\n+ \"\"\"Rename a notebook.\"\"\"\n+ ctx.client.rename_notebook(notebook_id, name)\n+ click.echo(f\"Renamed notebook {notebook_id} to: {name}\")\n+\n+\n+@notebook.command(\"open\")\n+@click.argument(\"notebook_id\")\n+@click.pass_obj\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\n+ \"\"\"Open a notebook.\"\"\"\n+ ctx.client.open_notebook(notebook_id)\n+ name = notebook_id\n+ for nb in ctx.client.list_notebooks():\n+ if nb.get(\"id\") == notebook_id:\n+ name = nb.get(\"name\", notebook_id)\n+ break\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\n+ ctx.session.flush()\n+ click.echo(f\"Opened notebook: {name} ({notebook_id})\")\n+\n+\n+# ── Document commands ──────────────────────────────────────────────────\n+\n+@cli.group()\n+def doc():\n+ \"\"\"Manage documents (文档).\"\"\"\n+\n+\n+@doc.command(\"create\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\")\n+@click.option(\"--md\", default=\"\", help=\"Markdown content. Use '-' to read from stdin.\")\n+@click.pass_obj\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\n+ \"\"\"Create a document with optional Markdown content.\n+\n+ To avoid shell escaping issues with special characters\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\n+ echo \"## Title\" | sy doc create nb1 /test --md -\n+ \"\"\"\n+ if md == \"-\":\n+ md = _read_stdin()\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"id\": doc_id}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Created doc: {doc_id}\")\n+\n+\n+@doc.command(\"list\")\n+@click.argument(\"notebook_id\")\n+@click.argument(\"path\", default=\"/\")\n+@click.pass_obj\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\n+ \"\"\"List documents at a path.\"\"\"\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\n+ items = docs.get(\"files\", []) if isinstance(docs, dict) else docs\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ click.echo(f\"{'ID':<30} {'Name':<30} {'Type':<10}\")\n+ click.echo(\"-\" * 70)\n+ for d in items:\n+ click.echo(f\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\")\n+\n+\n+@doc.command(\"tree\")\n+@click.argument(\"notebook_id\")\n+@click.option(\"--path\", default=\"/\", help=\"Root path\")\n+@click.option(\"--depth\", default=-1, type=int, help=\"Max depth\")\n+@click.pass_obj\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\n+ \"\"\"List document tree.\"\"\"\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\n+ if isinstance(tree, dict):\n+ items = tree.get(\"files\") or tree.get(\"tree\") or []\n+ else:\n+ items = tree\n+ if ctx.json_output:\n+ click.echo(json.dumps(items, ensure_ascii=False))\n+ else:\n+ for t in _walk_tree(items):\n+ indent = \" \" * t.get(\"depth\", 0)\n+ click.echo(f\"{indent}{t.get('name', '')} ({t.get('id', '')})\")\n+\n+\n+@doc.command(\"get\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_get(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Get document info by ID.\"\"\"\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"hpath\": hpath}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Path: {hpath}\")\n+\n+\n+@doc.command(\"rename\")\n+@click.argument(\"doc_id\")\n+@click.argument(\"title\")\n+@click.pass_obj\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\n+ \"\"\"Rename a document.\"\"\"\n+ ctx.client.rename_doc_by_id(doc_id, title)\n+ click.echo(f\"Renamed {doc_id} to: {title}\")\n+\n+\n+@doc.command(\"remove\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Remove a document.\"\"\"\n+ ctx.client.remove_doc_by_id(doc_id)\n+ click.echo(f\"Removed: {doc_id}\")\n+\n+\n+# ── Block commands ─────────────────────────────────────────────────────\n+\n+@cli.group()\n+def block():\n+ \"\"\"Manage blocks (内容块).\"\"\"\n+\n+\n+@block.command(\"insert\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--previous\", default=\"\", help=\"Previous block ID\")\n+@click.option(\"--parent\", default=\"\", help=\"Parent block ID\")\n+@click.option(\"--next\", \"next_\", default=\"\", help=\"Next block ID\")\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type (markdown/dom)\")\n+@click.pass_obj\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\n+ \"\"\"Insert a block. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not parent and not previous and not next_:\n+ raise click.UsageError(\"An anchor is required: --parent, --previous, or --next\")\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\n+ if ctx.json_output:\n+ click.echo(json.dumps(result, ensure_ascii=False))\n+ else:\n+ click.echo(\"Block inserted\")\n+\n+\n+@block.command(\"update\")\n+@click.argument(\"block_id\")\n+@click.argument(\"data\", required=False)\n+@click.option(\"--data-type\", default=\"markdown\", help=\"Data type\")\n+@click.pass_obj\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\n+ \"\"\"Update a block's content. Data reads from stdin when '-' or omitted.\"\"\"\n+ if not data or data == \"-\":\n+ data = _read_stdin()\n+ ctx.client.update_block(data_type, data, block_id)\n+ click.echo(f\"Updated block: {block_id}\")\n+\n+\n+@block.command(\"delete\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_delete(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Delete a block.\"\"\"\n+ ctx.client.delete_block(block_id)\n+ click.echo(f\"Deleted block: {block_id}\")\n+\n+\n+@block.command(\"get\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_get(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get block kramdown source.\"\"\"\n+ kramdown = ctx.client.get_block_kramdown(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"kramdown\": kramdown}, ensure_ascii=False))\n+ else:\n+ click.echo(kramdown)\n+\n+\n+@block.command(\"children\")\n+@click.argument(\"block_id\")\n+@click.pass_obj\n+def block_children(ctx: SiYuanContext, block_id: str):\n+ \"\"\"Get child blocks.\"\"\"\n+ children = ctx.client.get_child_blocks(block_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(children, ensure_ascii=False))\n+ else:\n+ for c in children:\n+ click.echo(f\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\")\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"stmt\")\n+@click.pass_obj\n+def sql(ctx: SiYuanContext, stmt: str):\n+ \"\"\"Execute a SQL query on the block database.\n+\n+ Example: sql \"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\"\n+ \"\"\"\n+ results = ctx.client.query_sql(stmt)\n+ if ctx.json_output:\n+ click.echo(json.dumps(results, ensure_ascii=False))\n+ elif not results:\n+ click.echo(\"No results\")\n+ else:\n+ for r in results:\n+ click.echo(json.dumps(r, ensure_ascii=False))\n+\n+\n+# ── Search commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.argument(\"query\")\n+@click.pass_obj\n+def search(ctx: SiYuanContext, query: str):\n+ \"\"\"Full-text search across all blocks.\"\"\"\n+ data = ctx.client.search_blocks(query)\n+ blocks = data.get(\"blocks\", []) if isinstance(data, dict) else data\n+ if ctx.json_output:\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\n+ elif not blocks:\n+ click.echo(\"No results\")\n+ else:\n+ for r in blocks[:20]:\n+ click.echo(f\"- {r.get('id', '')}: {r.get('content', '')[:120]}\")\n+\n+\n+# ── Export commands ────────────────────────────────────────────────────\n+\n+@cli.group()\n+def export():\n+ \"\"\"Export content from SiYuan.\"\"\"\n+\n+\n+@export.command(\"md\")\n+@click.argument(\"doc_id\")\n+@click.pass_obj\n+def export_md(ctx: SiYuanContext, doc_id: str):\n+ \"\"\"Export a document as Markdown.\"\"\"\n+ md = ctx.client.export_md_content(doc_id)\n+ if ctx.json_output:\n+ click.echo(json.dumps(md, ensure_ascii=False))\n+ else:\n+ click.echo(f\"# {md.get('hPath', '')}\")\n+ click.echo(\"\")\n+ click.echo(md.get(\"content\", \"\"))\n+\n+\n+# ── System commands ────────────────────────────────────────────────────\n+\n+@cli.command()\n+@click.pass_obj\n+def version(ctx: SiYuanContext):\n+ \"\"\"Show SiYuan kernel version.\"\"\"\n+ ver = ctx.client.get_version()\n+ if ctx.json_output:\n+ click.echo(json.dumps({\"version\": ver}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"SiYuan version: {ver}\")\n+\n+\n+@cli.command()\n+@click.pass_obj\n+def status(ctx: SiYuanContext):\n+ \"\"\"Show connection and session status.\"\"\"\n+ connected = ctx.client.ping()\n+ siyuan_ver = ctx.client.get_version() if connected else \"\"\n+ session = ctx.session\n+ state = session.state\n+\n+ info = {\n+ \"connected\": connected,\n+ \"siyuan_version\": siyuan_ver,\n+ \"host\": ctx.client.config.host,\n+ \"port\": ctx.client.config.port,\n+ \"current_notebook\": state.current_notebook_name or \"\",\n+ \"current_doc\": state.current_doc_path or \"\",\n+ }\n+\n+ if ctx.json_output:\n+ click.echo(json.dumps(info, ensure_ascii=False))\n+ else:\n+ click.echo(f\" Connected: {info['connected']}\")\n+ click.echo(f\" SiYuan: v{info['siyuan_version']}\")\n+ click.echo(f\" Host: {info['host']}:{info['port']}\")\n+ click.echo(f\" Notebook: {info['current_notebook']}\")\n+ click.echo(f\" Document: {info['current_doc']}\")\n+\n+\n+# ── Tag commands ───────────────────────────────────────────────────────\n+\n+@cli.group()\n+def tag():\n+ \"\"\"Manage tags (标签).\"\"\"\n+\n+\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\n+ \"\"\"Recursively print tags with hierarchical indentation.\"\"\"\n+ pad = \" \" * indent\n+ for t in tags:\n+ if indent == 0:\n+ click.echo(f\"{t.get('name', ''):<30} ({t.get('count', 0)})\")\n+ else:\n+ click.echo(f\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\")\n+ children = t.get(\"children\")\n+ if children:\n+ _print_tags(children, indent + 1)\n+\n+\n+@tag.command(\"list\")\n+@click.pass_obj\n+def tag_list(ctx: SiYuanContext):\n+ \"\"\"List all tags (including nested tags).\"\"\"\n+ tags = ctx.client.get_tags()\n+ if ctx.json_output:\n+ click.echo(json.dumps(tags, ensure_ascii=False))\n+ else:\n+ _print_tags(tags)\n"}],"string":"[\n {\n \"comment\": \"**<sub><sub></sub></sub> Pass parent ID to block insert in REPL**\\n\\nUpdate the REPL `block insert` path to pass the second argument as `parent_id`, not `previous_id`. The help text and command shape (`block insert <parent> <data>`) indicate users provide a parent block, but this call currently inserts relative to `previousID`, which places content in the wrong position (or fails when only a parent context is known).\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,692 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = cmd.strip().split()\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ if json_mode:\\n+ click.echo(json.dumps(docs, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in docs])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(tree, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Title\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"title\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in tree])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\" and len(parts) >= 4:\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], previous_id=parts[2] if len(parts) > 2 else \\\"\\\")\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Normalize REPL doc list responses before rendering**\\n\\nThe REPL `doc list` branch iterates `docs` as if it were a list of document objects, but SiYuan responses are often wrapped as a dict (e.g. with a `files` array, which the one-shot `doc list` command already handles). When that dict shape is returned, iteration yields keys (strings), so `d.get(...)` raises and the REPL command fails instead of listing documents.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,692 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = cmd.strip().split()\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ if json_mode:\\n+ click.echo(json.dumps(docs, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in docs])\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Normalize REPL search responses before table output**\\n\\nThe REPL `search` handler assumes `search_blocks` returns a list, but SiYuan commonly returns a dict containing a `blocks` array (which the one-shot `search` command already normalizes). If the dict form is returned, iterating `results` yields string keys and `r.get(...)` crashes, so search in REPL breaks for real API responses.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,692 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = cmd.strip().split()\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ if json_mode:\\n+ click.echo(json.dumps(docs, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in docs])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(tree, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Title\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"title\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in tree])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\" and len(parts) >= 4:\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], previous_id=parts[2] if len(parts) > 2 else \\\"\\\")\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ results = client.search_blocks(query)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in results])\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Report live connectivity in status output**\\n\\nUse a live connectivity value in `status` instead of `session.state.connected`. That session field is initialized to `False` and is never updated anywhere in this commit, so `status` reports `connected: false` even after successfully calling `get_version()`, which makes machine-readable status output inaccurate.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,692 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = cmd.strip().split()\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ if json_mode:\\n+ click.echo(json.dumps(docs, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in docs])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(tree, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Title\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"title\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in tree])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\" and len(parts) >= 4:\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], previous_id=parts[2] if len(parts) > 2 else \\\"\\\")\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ results = client.search_blocks(query)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in results])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ ctx.session.update(current_notebook_id=notebook_id)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {notebook_id}\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\\"\\\"\\\"\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ items = tree.get(\\\"tree\\\", []) if isinstance(tree, dict) else tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in items:\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('title', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\")\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str, previous: str, parent: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block.\\\"\\\"\\\"\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content.\\\"\\\"\\\"\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ siyuan_ver = ctx.client.get_version()\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": state.connected,\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Parse REPL input with shell-style tokenization**\\n\\nThe REPL parser uses `cmd.strip().split()`, which loses quoting and breaks multi-word arguments. As a result, commands that rely on positional tokens (for example `block insert`, `block update`, and `doc create --md`) only receive a fragment of the intended payload or include literal quote characters, so markdown with spaces is inserted/updated incorrectly. This is a functional data-loss bug for normal note content entered in REPL.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,696 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = cmd.strip().split()\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Catch request timeouts and transport errors uniformly**\\n\\n`_post` only converts `requests.ConnectionError` into `SiYuanClientError`, but other common transport failures (for example timeouts/read errors/SSL errors) bubble up as raw exceptions. In those cases callers that handle `SiYuanClientError` won't catch the failure, so users get unhandled errors instead of the intended CLI error message path.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,284 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\\n+ return SiYuanConfig(\\n+ host=data.get(\\\"host\\\", \\\"127.0.0.1\\\"),\\n+ port=data.get(\\\"port\\\", 6806),\\n+ token=data.get(\\\"token\\\", \\\"\\\"),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Normalize createNotebook payload before returning**\\n\\n`create_notebook()` currently returns the raw `data` object from `/api/notebook/createNotebook`, but SiYuan’s API shape is `{\\\"notebook\\\": {...}}` for that endpoint. Downstream code paths (`notebook create` and REPL notebook creation) read `nb[\\\"id\\\"]`/`nb[\\\"name\\\"]` directly, so real API responses trigger a `KeyError` instead of creating and reporting the notebook.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,292 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\\n+ return SiYuanConfig(\\n+ host=data.get(\\\"host\\\", \\\"127.0.0.1\\\"),\\n+ port=data.get(\\\"port\\\", 6806),\\n+ token=data.get(\\\"token\\\", \\\"\\\"),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Require an anchor for block insert**\\n\\nThis command allows `block insert <data>` with both `--parent` and `--previous` empty, then calls `insertBlock` without any position anchor. The SiYuan API requires at least one of `nextID`, `previousID`, or `parentID` for `/api/block/insertBlock`, so the default invocation path fails at runtime unless users discover and pass extra flags.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,697 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ items = tree.get(\\\"tree\\\", []) if isinstance(tree, dict) else tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Title\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"title\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\" and len(parts) >= 4:\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ ctx.session.update(current_notebook_id=notebook_id)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {notebook_id}\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\\"\\\"\\\"\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ items = tree.get(\\\"tree\\\", []) if isinstance(tree, dict) else tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in items:\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('title', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\")\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str, previous: str, parent: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block.\\\"\\\"\\\"\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous)\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Persist REPL session state before exit**\\n\\nThe REPL loop breaks immediately on `quit/exit/q` without flushing the session, but multiple REPL commands call `get_session().update(...)` and only mark the state dirty. Because `SessionManager` persists changes only on `flush()`/`save()`, notebook/document context changes made during a REPL session are lost after exiting and are not available in the next run.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,703 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ break\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Handle malformed config JSON without crashing**\\n\\n`load_config()` parses `~/.siyuan-cli.json` with `json.loads(...)` and does not catch decode/read errors. If a user has an invalid or partially written config file, every CLI command crashes during startup instead of reporting a friendly config error or falling back to env/defaults, which effectively bricks the CLI until the file is manually fixed.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,295 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Flush the REPL session via the context object**\\n\\nWhen a user exits the REPL with `quit`, `exit`, or `q`, `ctx` is the Click context and does not have a `session` attribute; the session manager is available as the local `session` variable or `ctx.obj.session`. Because this branch is outside the command handler's `try`, normal REPL exit raises `AttributeError` instead of saving dirty state and printing the goodbye message.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,704 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.session.flush()\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Fall back to environment after invalid config**\\n\\nThe current malformed-config handler avoids the JSON crash, but it sets `data = {}` and then immediately returns default host/port/token values from the file branch, so a user with a bad or partially written `~/.siyuan-cli.json` cannot recover by setting `SIYUAN_TOKEN`/`SIYUAN_HOST` as documented. In that scenario the CLI silently drops the env credentials and continues unauthenticated/defaulted until the file is manually fixed.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,298 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = {}\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Convert API errors before leaving one-shot commands**\\n\\nWhen a one-shot command hits a normal SiYuan API failure such as a bad token or non-zero API `code`, `_post()` raises `SiYuanClientError`, but this command path has no handler and `SiYuanClientError` is not a Click exception. I verified the one-shot path with `CliRunner`: `notebook list` exits with the raw exception and no CLI error output, so users running documented commands get a traceback instead of the intended friendly error handling that the REPL already provides.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,704 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ items = tree.get(\\\"tree\\\", []) if isinstance(tree, dict) else tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Title\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"title\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Read doc-tree entries from the files key**\\n\\nWhen SiYuan returns the documented `/api/filetree/listDocTree` shape, `data` is a dict containing a `files` array, not a `tree` array; I checked the filetree/listDocTree API docs/source links. In that common response path this line turns the result into `[]`, so `cli-anything-siyuan doc tree <notebook>` reports an empty tree even when documents exist. The REPL branch has the same normalization pattern, so both paths should read `files` (and render the returned `name` field rather than `title`).\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,715 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ items = tree.get(\\\"tree\\\", []) if isinstance(tree, dict) else tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Title\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"title\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ ctx.session.update(current_notebook_id=notebook_id)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {notebook_id}\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\\"\\\"\\\"\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ items = tree.get(\\\"tree\\\", []) if isinstance(tree, dict) else tree\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Request the uncapped tag list**\\n\\nWhen a workspace has more tags than SiYuan's `Conf.FileTree.MaxListCount`, `/api/tag/getTag` stops building the response unless the request includes `ignoreMaxListHint: true`; this makes both `tag list` and `--json tag list` silently omit the remaining tags even though the command is documented as listing all tags. Pass that flag here before rendering the result so large/tag-heavy workspaces are complete.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,300 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ return SiYuanConfig(\\n+ host=data.get(\\\"host\\\", \\\"127.0.0.1\\\"),\\n+ port=data.get(\\\"port\\\", 6806),\\n+ token=data.get(\\\"token\\\", \\\"\\\"),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"keyword\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/searchTag\\\", {\\\"tag\\\": tag})\\n+\\n+ def find_replace(self, keyword: str, replacement: str, notebook_id: str = \\\"\\\", path: str = \\\"\\\", max_count: int = 0) -> int:\\n+ data = self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"keyword\\\": keyword, \\\"replacement\\\": replacement,\\n+ \\\"notebookID\\\": notebook_id, \\\"path\\\": path, \\\"maxCount\\\": max_count,\\n+ })\\n+ return data.get(\\\"count\\\", 0)\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {})\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Clear or refresh the notebook name when opening**\\n\\nWhen a session already has `current_notebook_name` set and the user runs `notebook open <different-id>`, this only changes the ID and flushes the stale name back to disk. The `status` command and REPL prompt render `current_notebook_name`, so they continue to report the previous notebook after a successful open; fetch the notebook name or clear it when updating the ID.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,719 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ items = tree.get(\\\"files\\\", []) if isinstance(tree, dict) else tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ ctx.session.update(current_notebook_id=notebook_id)\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Traverse nested tags in text output**\\n\\nIn workspaces that use hierarchical tags, SiYuan returns child tags under each tag's `children` field, but this text output loop only prints the top-level entries. That makes `tag list` omit nested tags even though `--json tag list` includes them, contradicting the command's \\\"List all tags\\\" behavior for users who rely on the human-readable output.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,719 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ items = tree.get(\\\"files\\\", []) if isinstance(tree, dict) else tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ ctx.session.update(current_notebook_id=notebook_id)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {notebook_id}\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\\"\\\"\\\"\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ items = tree.get(\\\"files\\\", []) if isinstance(tree, dict) else tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in items:\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = click.get_text_stream(\\\"stdin\\\").read()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = click.get_text_stream(\\\"stdin\\\").read()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags.\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ for t in tags:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Point dev fallback at an executable module**\\n\\nWhen the console script is not installed, this fallback resolves `cli-anything-siyuan` to `python -m cli_anything.siyuan.siyuan_cli`, but `siyuan_cli.py` only defines the Click group and has no `if __name__ == \\\"__main__\\\": cli()` invocation; in a dev environment with dependencies installed the subprocess exits without running Click, so the E2E help/version tests assert against empty stdout. Use the package module that has `__main__.py` (`cli_anything.siyuan`) or add the missing module entrypoint.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py\",\n \"hunk\": \"@@ -0,0 +1,122 @@\\n+\\\"\\\"\\\"E2E tests for cli-anything-siyuan.\\n+\\n+Requires a running SiYuan instance at http://127.0.0.1:6806.\\n+Set SIYUAN_TOKEN env var if authentication is enabled.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.siyuan.core.client import SiYuanClient, SiYuanClientError, load_config\\n+\\n+\\n+def _resolve_cli(name: str) -> list[str]:\\n+ \\\"\\\"\\\"Resolve installed CLI command; falls back to python -m for dev.\\\"\\\"\\\"\\n+ import shutil\\n+ force = os.environ.get(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"\\\").strip() == \\\"1\\\"\\n+ path = shutil.which(name)\\n+ if path:\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+ if force:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ module = name.replace(\\\"cli-anything-\\\", \\\"cli_anything.\\\") + \\\".\\\" + name.split(\\\"-\\\")[-1] + \\\"_cli\\\"\\n+ print(f\\\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py b/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py\\nnew file mode 100644\\nindex 000000000..2efee700a\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py\\n@@ -0,0 +1,122 @@\\n+\\\"\\\"\\\"E2E tests for cli-anything-siyuan.\\n+\\n+Requires a running SiYuan instance at http://127.0.0.1:6806.\\n+Set SIYUAN_TOKEN env var if authentication is enabled.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.siyuan.core.client import SiYuanClient, SiYuanClientError, load_config\\n+\\n+\\n+def _resolve_cli(name: str) -> list[str]:\\n+ \\\"\\\"\\\"Resolve installed CLI command; falls back to python -m for dev.\\\"\\\"\\\"\\n+ import shutil\\n+ force = os.environ.get(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"\\\").strip() == \\\"1\\\"\\n+ path = shutil.which(name)\\n+ if path:\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+ if force:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ module = name.replace(\\\"cli-anything-\\\", \\\"cli_anything.\\\") # e.g. cli_anything.siyuan (has __main__.py)\\n+ print(f\\\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+\\n+CLI_BASE = _resolve_cli(\\\"cli-anything-siyuan\\\")\\n+\\n+\\n+# ── Fixtures ───────────────────────────────────────────────────────────\\n+\\n+@pytest.fixture(scope=\\\"session\\\")\\n+def client() -> SiYuanClient:\\n+ \\\"\\\"\\\"Create a client connected to the real SiYuan instance.\\\"\\\"\\\"\\n+ config = load_config()\\n+ c = SiYuanClient(config)\\n+ if not c.ping():\\n+ pytest.skip(\\\"SiYuan is not running — E2E tests require a running instance\\\")\\n+ return c\\n+\\n+\\n+@pytest.fixture\\n+def tmp_dir() -> Path:\\n+ \\\"\\\"\\\"Create a temporary directory for test artifacts.\\\"\\\"\\\"\\n+ import tempfile\\n+ path = Path(tempfile.mkdtemp(prefix=\\\"siyuan_e2e_\\\"))\\n+ yield path\\n+ import shutil\\n+ shutil.rmtree(path, ignore_errors=True)\\n+\\n+\\n+class TestCLISubprocess:\\n+ CLI_BASE = CLI_BASE\\n+\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess:\\n+ return subprocess.run(\\n+ self.CLI_BASE + args,\\n+ capture_output=True, text=True, check=check,\\n+ )\\n+\\n+ def test_help(self):\\n+ \\\"\\\"\\\"--help returns 0 and shows usage.\\\"\\\"\\\"\\n+ result = self._run([\\\"--help\\\"])\\n+ assert result.returncode == 0\\n+ assert \\\"Usage:\\\" in result.stdout\\n+ print(f\\\"\\\\n --help: OK ({len(result.stdout)} chars)\\\")\\n+\\n+ def test_version_json(self, client: SiYuanClient):\\n+ \\\"\\\"\\\"--json version returns valid JSON with version string.\\\"\\\"\\\"\\n+ result = self._run([\\\"--json\\\", \\\"version\\\"])\\n+ assert result.returncode == 0\\n+ data = json.loads(result.stdout)\\n+ assert \\\"version\\\" in data\\n+ assert data[\\\"version\\\"]\\n+ print(f\\\"\\\\n SiYuan version: {data['version']}\\\")\\n+\\n+ def test_status_json(self, client: SiYuanClient):\\n+ \\\"\\\"\\\"--json status returns valid JSON with connection info.\\\"\\\"\\\"\\n+ result = self._run([\\\"--json\\\", \\\"status\\\"])\\n+ assert result.returncode == 0\\n+ data = json.loads(result.stdout)\\n+ assert \\\"siyuan_version\\\" in data\\n+ assert data[\\\"siyuan_version\\\"]\\n+ print(f\\\"\\\\n Status: connected to SiYuan v{data['siyuan_version']}\\\")\\n+\\n+\\n+class TestBackendE2E:\\n+ \\\"\\\"\\\"Tests that hit the real SiYuan API via Python client.\\\"\\\"\\\"\\n+\\n+ def test_get_version(self, client: SiYuanClient):\\n+ \\\"\\\"\\\"Get the SiYuan kernel version from a running instance.\\\"\\\"\\\"\\n+ ver = client.get_version()\\n+ assert ver\\n+ assert isinstance(ver, str)\\n+ assert len(ver) > 0\\n+ print(f\\\"\\\\n SiYuan kernel version: {ver}\\\")\\n+\\n+ def test_list_notebooks(self, client: SiYuanClient):\\n+ \\\"\\\"\\\"List all notebooks from the running instance.\\\"\\\"\\\"\\n+ notebooks = client.list_notebooks()\\n+ assert isinstance(notebooks, list)\\n+ if notebooks:\\n+ nb = notebooks[0]\\n+ assert \\\"id\\\" in nb\\n+ assert \\\"name\\\" in nb\\n+ print(f\\\"\\\\n Notebooks found: {len(notebooks)}\\\")\\n+ print(f\\\" First: {nb['name']} ({nb['id']})\\\")\\n+ else:\\n+ print(\\\"\\\\n No notebooks found (empty instance)\\\")\\n+\\n+ def test_get_current_time(self, client: SiYuanClient):\\n+ \\\"\\\"\\\"Get current time from server.\\\"\\\"\\\"\\n+ t = client.get_current_time()\\n+ assert t > 0\\n+ assert isinstance(t, int)\\n+ print(f\\\"\\\\n Server time (ts): {t}\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Put Markdown content behind --md in the skill example**\\n\\nWhen agents follow this skill example to create a document with initial content, Click receives the Markdown as a third positional argument even though `doc create` only declares `notebook_id` and `path` plus the `--md` option, so the command exits with an unexpected-extra-argument error before creating anything. Use the documented shape, e.g. `doc create nb1 /projects/new --md ...`, so the installed skill does not teach a failing workflow.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"skills/cli-anything-siyuan/SKILL.md\",\n \"hunk\": \"@@ -0,0 +1,93 @@\\n+---\\n+name: \\\"cli-anything-siyuan\\\"\\n+description: SiYuan (思源笔记) CLI — manage notebooks, documents, blocks, and search your knowledge base from the terminal.\\n+---\\n+\\n+# cli-anything-siyuan\\n+\\n+CLI harness for [SiYuan](https://github.com/siyuan-note/siyuan) (思源笔记),\\n+a local-first knowledge management and note-taking application.\\n+\\n+This CLI connects to a running SiYuan kernel via its HTTP API\\n+(`http://127.0.0.1:6806`) and provides structured access to notebooks,\\n+documents, blocks, search, and export.\\n+\\n+## Prerequisites\\n+\\n+- SiYuan must be running (Settings → About shows the API token)\\n+- Python 3.10+\\n+- Install: `pip install cli-anything-siyuan` or `pip install -e .` from agent-harness/\\n+\\n+## Command Groups\\n+\\n+### notebook — Notebook management\\n+| Subcommand | Description |\\n+|------------|-------------|\\n+| `list` | List all notebooks |\\n+| `create <name>` | Create a new notebook |\\n+| `rename <id> <name>` | Rename a notebook |\\n+| `remove <id>` | Delete a notebook |\\n+| `open <id>` | Open a notebook |\\n+\\n+### doc — Document management\\n+| Subcommand | Description |\\n+|------------|-------------|\\n+| `create <notebook> <path> [--md \\\"content\\\"]` | Create a document |\\n+| `list <notebook> [path]` | List documents |\\n+| `tree <notebook> [--path / --depth]` | Show doc tree |\\n+| `get <id>` | Get document path by ID |\\n+| `rename <id> <title>` | Rename a document |\\n+| `remove <id>` | Delete a document |\\n+\\n+### block — Block operations\\n+| Subcommand | Description |\\n+|------------|-------------|\\n+| `insert <data> [--previous / --parent]` | Insert a block |\\n+| `update <id> <data>` | Update a block |\\n+| `delete <id>` | Delete a block |\\n+| `get <id>` | Get block kramdown source |\\n+| `children <id>` | Get child blocks |\\n+\\n+### Other commands\\n+| Command | Description |\\n+|---------|-------------|\\n+| `sql <stmt>` | Execute SQL on the block database |\\n+| `search <query>` | Full-text search across blocks |\\n+| `export md <doc-id>` | Export document as Markdown |\\n+| `tag list` | List all tags |\\n+| `version` | Show SiYuan kernel version |\\n+| `status` | Show connection and session status |\\n+| `repl` | Start interactive REPL |\\n+\\n+## Agent Guidance\\n+\\n+- Always use `--json` for machine-readable output\\n+- Power search: use `sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%'\\\"` for SQL-level access\\n+- Document IDs look like `20210817205410-2kvfpfn` (timestamp-based)\\n+- API token can be found in SiYuan Settings → About\\n+- Connection defaults: `http://127.0.0.1:6806`\\n+\\n+## Examples\\n+\\n+```bash\\n+# List notebooks (JSON)\\n+cli-anything-siyuan --json notebook list\\n+\\n+# Create a document with Markdown\\n+cli-anything-siyuan doc create nb1 /projects/new \\\"## Title\\\\n\\\\nContent\\\"\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/skills/cli-anything-siyuan/SKILL.md b/skills/cli-anything-siyuan/SKILL.md\\nnew file mode 100644\\nindex 000000000..9c594d521\\n--- /dev/null\\n+++ b/skills/cli-anything-siyuan/SKILL.md\\n@@ -0,0 +1,106 @@\\n+---\\n+name: \\\"cli-anything-siyuan\\\"\\n+description: SiYuan (思源笔记) CLI — manage notebooks, documents, blocks, and search your knowledge base from the terminal.\\n+---\\n+\\n+# cli-anything-siyuan\\n+\\n+CLI harness for [SiYuan](https://github.com/siyuan-note/siyuan) (思源笔记),\\n+a local-first knowledge management and note-taking application.\\n+\\n+This CLI connects to a running SiYuan kernel via its HTTP API\\n+(`http://127.0.0.1:6806`) and provides structured access to notebooks,\\n+documents, blocks, search, and export.\\n+\\n+## Prerequisites\\n+\\n+- SiYuan must be running (Settings → About shows the API token)\\n+- Python 3.10+\\n+- Install: `pip install cli-anything-siyuan` or `pip install -e .` from agent-harness/\\n+\\n+## Command Groups\\n+\\n+### notebook — Notebook management\\n+| Subcommand | Description |\\n+|------------|-------------|\\n+| `list` | List all notebooks |\\n+| `create <name>` | Create a new notebook |\\n+| `rename <id> <name>` | Rename a notebook |\\n+| `remove <id>` | Delete a notebook |\\n+| `open <id>` | Open a notebook |\\n+\\n+### doc — Document management\\n+| Subcommand | Description |\\n+|------------|-------------|\\n+| `create <notebook> <path> [--md \\\"content\\\"]` | Create a document |\\n+| `list <notebook> [path]` | List documents |\\n+| `tree <notebook> [--path / --depth]` | Show doc tree |\\n+| `get <id>` | Get document path by ID |\\n+| `rename <id> <title>` | Rename a document |\\n+| `remove <id>` | Delete a document |\\n+\\n+### block — Block operations\\n+| Subcommand | Description |\\n+|------------|-------------|\\n+| `insert <data> [--previous / --parent]` | Insert a block |\\n+| `update <id> <data>` | Update a block |\\n+| `delete <id>` | Delete a block |\\n+| `get <id>` | Get block kramdown source |\\n+| `children <id>` | Get child blocks |\\n+\\n+### Other commands\\n+| Command | Description |\\n+|---------|-------------|\\n+| `sql <stmt>` | Execute SQL on the block database |\\n+| `search <query>` | Full-text search across blocks |\\n+| `export md <doc-id>` | Export document as Markdown |\\n+| `tag list` | List all tags |\\n+| `version` | Show SiYuan kernel version |\\n+| `status` | Show connection and session status |\\n+| `repl` | Start interactive REPL |\\n+\\n+## Agent Guidance\\n+\\n+- Always use `--json` for machine-readable output\\n+- Power search: use `sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%'\\\"` for SQL-level access\\n+- Document IDs look like `20210817205410-2kvfpfn` (timestamp-based)\\n+- API token can be found in SiYuan Settings → About\\n+- Connection defaults: `http://127.0.0.1:6806`\\n+\\n+## Examples\\n+\\n+```bash\\n+# List notebooks (JSON)\\n+cli-anything-siyuan --json notebook list\\n+\\n+# Create a document with Markdown (--md flag, watch shell escaping)\\n+cli-anything-siyuan doc create nb1 /projects/new --md \\\"## Title\\\\n\\\\nContent\\\"\\n+\\n+# Create a document — pipe Markdown via stdin (avoids shell escaping)\\n+# PowerShell here-string (literal, no escaping needed):\\n+@'\\n+## Title\\n+Content with `backticks` and (parentheses) and \\\"quotes\\\"\\n+'@ | cli-anything-siyuan doc create nb1 /projects/new --md -\\n+\\n+# Bash heredoc:\\n+# cat <<'EOF' | cli-anything-siyuan doc create nb1 /projects/new --md -\\n+# ## Title\\n+# Content with `backticks` and (parentheses)\\n+# EOF\\n+\\n+# SQL search\\n+cli-anything-siyuan sql \\\"SELECT id, content FROM blocks WHERE content LIKE '%meeting%' LIMIT 5\\\"\\n+\\n+# Export\\n+cli-anything-siyuan export md doc123\\n+\\n+# Enter REPL\\n+cli-anything-siyuan\\n+```\\n+\\n+## Error Handling\\n+\\n+- Connection errors: check that SiYuan is running and the API token is correct\\n+- API errors: returned as `{\\\"code\\\": N, \\\"msg\\\": \\\"...\\\"}` — check the message field\\n+- Auth errors: verify the token in `~/.siyuan-cli.json` or `SIYUAN_TOKEN` env var\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Honor environment overrides when config exists**\\n\\nWhen a valid `~/.siyuan-cli.json` exists, this early return ignores `SIYUAN_HOST`, `SIYUAN_PORT`, and `SIYUAN_TOKEN` entirely. In environments where users rely on the documented env vars to override a stale local config or to supply a token that is omitted from the file, the CLI continues with the file/default credentials and fails to authenticate; read the file as defaults but apply env values before returning.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,300 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ return SiYuanConfig(\\n+ host=data.get(\\\"host\\\", \\\"127.0.0.1\\\"),\\n+ port=data.get(\\\"port\\\", 6806),\\n+ token=data.get(\\\"token\\\", \\\"\\\"),\\n+ )\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Avoid blocking empty doc creation on stdin**\\n\\nWhen users follow the documented `doc create <notebook-id> <path>` form from an interactive shell and omit `--md`, this branch reads from stdin and waits for EOF instead of creating an empty document. SiYuan accepts an empty `markdown` value for this API, so only the explicit `--md -` case should consume stdin; otherwise the basic create command can appear hung.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,743 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle emoji and CJK characters on Windows\\n+ if hasattr(sys.stdout, 'reconfigure'):\\n+ sys.stdout.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ items = tree.get(\\\"files\\\", []) if isinstance(tree, dict) else tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' or omit to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if not md or md == \\\"-\\\":\\n+ md = click.get_text_stream(\\\"stdin\\\").read()\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Support tree-shaped doc tree responses**\\n\\nWhen SiYuan returns `/api/filetree/listDocTree` data under the `tree` key, this normalization drops the entire result because it only accepts `files` from dict responses. I checked the SiYuan v3.4.2 kernel `api/filetree.go`, where `listDocTree` sets `ret.Data = {\\\"tree\\\": doctree}`, so `cli-anything-siyuan doc tree ...` will print no documents for those kernels even though the API succeeded; please accept both `files` and `tree` before falling back to an empty list.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,758 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ items = tree.get(\\\"files\\\", []) if isinstance(tree, dict) else tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' or omit to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if not md or md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ items = tree.get(\\\"files\\\", []) if isinstance(tree, dict) else tree\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Traverse doc-tree children before rendering**\\n\\nWhen `/api/filetree/listDocTree` returns the tree-shaped response, nested documents are stored under each node's `children` field, but this text renderer only iterates the top-level `items`. In any notebook with documents inside subdocuments/folders, `doc tree <notebook>` omits all descendants even though the command is meant to show the full document tree; flatten or recursively print `children` here (and in the REPL path) before rendering.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,764 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+from cli_anything.siyuan.utils.siyuan_backend import check_siyuan_running\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Global state ───────────────────────────────────────────────────────\\n+\\n+_config: SiYuanConfig | None = None\\n+_client: SiYuanClient | None = None\\n+_session_mgr: SessionManager | None = None\\n+\\n+\\n+def get_client() -> SiYuanClient:\\n+ global _client, _config\\n+ if _client is None:\\n+ _config = load_config()\\n+ _client = SiYuanClient(_config)\\n+ return _client\\n+\\n+\\n+def get_session() -> SessionManager:\\n+ global _session_mgr\\n+ if _session_mgr is None:\\n+ _session_mgr = SessionManager()\\n+ _session_mgr.load()\\n+ return _session_mgr\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = get_client()\\n+ self.session = get_session()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ global _config, _client\\n+ if host or port or token or config_path:\\n+ cfg = load_config(config_path or None)\\n+ _config = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ _client = SiYuanClient(_config)\\n+ ctx.obj = SiYuanContext(json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not get_client().ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ try:\\n+ kernel_version = get_client().get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ session = get_session()\\n+ state = session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ ctx.obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(state.connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _handle_repl_command(skin, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _handle_repl_command(skin: Any, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse and execute a REPL command.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ client = get_client()\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ # notebook commands\\n+ if parts[0] == \\\"notebook\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ get_session().update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+ # doc commands\\n+ elif parts[0] == \\\"doc\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ get_session().update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in items])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+ # block commands\\n+ elif parts[0] == \\\"block\\\":\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ result = client.insert_block(\\\"markdown\\\", parts[3], parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ client.prepend_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ client.append_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ client.update_block(\\\"markdown\\\", parts[3], parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+ # sql command\\n+ elif parts[0] == \\\"sql\\\" and len(parts) >= 2:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+ # search command\\n+ elif parts[0] == \\\"search\\\" and len(parts) >= 2:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+ # export command\\n+ elif parts[0] == \\\"export\\\" and len(parts) >= 3:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in items:\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Send the tag query as k**\\n\\nWhen callers use this client helper, SiYuan's `searchTag` handler reads the query from `arg[\\\"k\\\"]` and returns a dict containing `tags`; sending `tag` leaves the required key unset, so real kernels fail before searching instead of returning matching tags. Use the `k` payload key and unwrap the returned `tags` array.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,301 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"keyword\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/searchTag\\\", {\\\"tag\\\": tag})\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Use SiYuan's findReplace payload shape**\\n\\nWhen this helper is used, SiYuan's `/api/search/findReplace` handler expects `k`, `r`, and an `ids` array (plus the usual search filters), and successful calls return null data rather than a count object. This payload sends unrelated key names and then calls `.get()` on the null success data, so the method cannot perform a normal find/replace call against a real kernel.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,301 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"keyword\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/searchTag\\\", {\\\"tag\\\": tag})\\n+\\n+ def find_replace(self, keyword: str, replacement: str, notebook_id: str = \\\"\\\", path: str = \\\"\\\", max_count: int = 0) -> int:\\n+ data = self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"keyword\\\": keyword, \\\"replacement\\\": replacement,\\n+ \\\"notebookID\\\": notebook_id, \\\"path\\\": path, \\\"maxCount\\\": max_count,\\n+ })\\n+ return data.get(\\\"count\\\", 0)\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Request uncapped document listings**\\n\\nWhen a path contains more children than SiYuan's `FileTree.MaxListCount`, `/api/filetree/listDocsByPath` defaults to that cap unless `maxListCount` is supplied (with `0`/negative disabling the cap). Because this helper sends only `notebook` and `path`, both `doc list` and the REPL `doc list` can silently render only the first capped subset while the command is described as listing the directory; pass `maxListCount: 0` or expose a limit option for the list-all behavior.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,305 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Send the document search term as k**\\n\\nWhen this public helper is used against SiYuan's `/api/filetree/searchDocs`, the kernel reads the search string from `arg[\\\"k\\\"]`; sending `keyword` leaves the required key absent, so real kernels fail the request instead of returning matching documents. Use the payload key `k` here to make `search_docs()` usable.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/core/client.py\",\n \"hunk\": \"@@ -0,0 +1,305 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"keyword\\\": keyword})\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/core/client.py b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\nnew file mode 100644\\nindex 000000000..f274d8810\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/core/client.py\\n@@ -0,0 +1,307 @@\\n+\\\"\\\"\\\"SiYuan HTTP API client.\\n+\\n+Handles connection, authentication, and request/response to the SiYuan kernel.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import requests\\n+\\n+\\n+@dataclass(frozen=True)\\n+class SiYuanConfig:\\n+ host: str = \\\"127.0.0.1\\\"\\n+ port: int = 6806\\n+ token: str = \\\"\\\"\\n+\\n+ @property\\n+ def base_url(self) -> str:\\n+ return f\\\"http://{self.host}:{self.port}\\\"\\n+\\n+\\n+def load_config(config_path: str | None = None) -> SiYuanConfig:\\n+ \\\"\\\"\\\"Load SiYuan connection config from file or environment.\\n+\\n+ Priority: explicit path -> env vars -> defaults.\\n+ Config file is JSON: {\\\"host\\\": \\\"...\\\", \\\"port\\\": 6806, \\\"token\\\": \\\"...\\\"}\\n+ \\\"\\\"\\\"\\n+ if config_path:\\n+ config_file = Path(config_path)\\n+ else:\\n+ config_file = Path.home() / \\\".siyuan-cli.json\\\"\\n+\\n+ if config_file.is_file():\\n+ try:\\n+ data = json.loads(config_file.read_text(encoding=\\\"utf-8-sig\\\"))\\n+ except (json.JSONDecodeError, OSError):\\n+ data = None\\n+\\n+ if data is not None:\\n+ # File values as base, env vars override\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", data.get(\\\"host\\\", \\\"127.0.0.1\\\")),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", data.get(\\\"port\\\", 6806))),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", data.get(\\\"token\\\", \\\"\\\")),\\n+ )\\n+\\n+ return SiYuanConfig(\\n+ host=os.environ.get(\\\"SIYUAN_HOST\\\", \\\"127.0.0.1\\\"),\\n+ port=int(os.environ.get(\\\"SIYUAN_PORT\\\", \\\"6806\\\")),\\n+ token=os.environ.get(\\\"SIYUAN_TOKEN\\\", \\\"\\\"),\\n+ )\\n+\\n+\\n+class SiYuanClientError(Exception):\\n+ \\\"\\\"\\\"Raised when the SiYuan API returns an error.\\\"\\\"\\\"\\n+\\n+\\n+class SiYuanClient:\\n+ \\\"\\\"\\\"HTTP client for the SiYuan kernel API.\\\"\\\"\\\"\\n+\\n+ def __init__(self, config: SiYuanConfig | None = None):\\n+ self.config = config or load_config()\\n+ self._session = requests.Session()\\n+ self._session.trust_env = False\\n+ if self.config.token:\\n+ self._session.headers[\\\"Authorization\\\"] = f\\\"Token {self.config.token}\\\"\\n+ self._session.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n+\\n+ def _post(self, endpoint: str, data: dict[str, Any] | None = None) -> Any:\\n+ \\\"\\\"\\\"Make a POST request to the SiYuan API.\\\"\\\"\\\"\\n+ url = f\\\"{self.config.base_url}{endpoint}\\\"\\n+ try:\\n+ resp = self._session.post(url, json=data or {}, timeout=30)\\n+ except requests.ConnectionError as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Cannot connect to SiYuan at {self.config.base_url}. \\\"\\n+ f\\\"Is SiYuan running? ({e})\\\"\\n+ ) from e\\n+ except requests.Timeout as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan timed out after 30s ({e})\\\"\\n+ ) from e\\n+ except requests.RequestException as e:\\n+ raise SiYuanClientError(\\n+ f\\\"Request to SiYuan failed: {e}\\\"\\n+ ) from e\\n+\\n+ if resp.status_code != 200:\\n+ raise SiYuanClientError(\\n+ f\\\"API returned status {resp.status_code}: {resp.text[:200]}\\\"\\n+ )\\n+\\n+ body = resp.json()\\n+ if body.get(\\\"code\\\", 0) != 0:\\n+ raise SiYuanClientError(\\n+ f\\\"API error: {body.get('msg', 'unknown error')}\\\"\\n+ )\\n+ return body.get(\\\"data\\\")\\n+\\n+ def ping(self) -> bool:\\n+ \\\"\\\"\\\"Check if SiYuan kernel is reachable.\\\"\\\"\\\"\\n+ try:\\n+ return self._post(\\\"/api/system/version\\\") is not None\\n+ except SiYuanClientError:\\n+ return False\\n+\\n+ # ── Notebook API ───────────────────────────────────────────────────\\n+\\n+ def list_notebooks(self) -> list[dict[str, Any]]:\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/notebook/lsNotebooks\\\")\\n+ return data.get(\\\"notebooks\\\", [])\\n+\\n+ def open_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/openNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def close_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/closeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def create_notebook(self, name: str) -> dict[str, Any]:\\n+ data = self._post(\\\"/api/notebook/createNotebook\\\", {\\\"name\\\": name})\\n+ if isinstance(data, dict) and \\\"notebook\\\" in data:\\n+ return data[\\\"notebook\\\"]\\n+ return data\\n+\\n+ def remove_notebook(self, notebook_id: str) -> None:\\n+ self._post(\\\"/api/notebook/removeNotebook\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def rename_notebook(self, notebook_id: str, name: str) -> None:\\n+ self._post(\\\"/api/notebook/renameNotebook\\\", {\\\"notebook\\\": notebook_id, \\\"name\\\": name})\\n+\\n+ def get_notebook_conf(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookConf\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ def set_notebook_conf(self, notebook_id: str, conf: dict[str, Any]) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/setNotebookConf\\\", {\\\"notebook\\\": notebook_id, \\\"conf\\\": conf})\\n+\\n+ def set_notebook_icon(self, notebook_id: str, icon: str) -> None:\\n+ self._post(\\\"/api/notebook/setNotebookIcon\\\", {\\\"notebook\\\": notebook_id, \\\"icon\\\": icon})\\n+\\n+ def get_notebook_info(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/notebook/getNotebookInfo\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Document / Filetree API ────────────────────────────────────────\\n+\\n+ def create_doc_with_md(self, notebook_id: str, path: str, markdown: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Create a document with Markdown content. Returns the doc ID.\\\"\\\"\\\"\\n+ return self._post(\\\"/api/filetree/createDocWithMd\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"markdown\\\": markdown,\\n+ })\\n+\\n+ def rename_doc(self, notebook_id: str, path: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"title\\\": title})\\n+\\n+ def rename_doc_by_id(self, doc_id: str, title: str) -> None:\\n+ self._post(\\\"/api/filetree/renameDocByID\\\", {\\\"id\\\": doc_id, \\\"title\\\": title})\\n+\\n+ def remove_doc(self, notebook_id: str, path: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDoc\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def remove_doc_by_id(self, doc_id: str) -> None:\\n+ self._post(\\\"/api/filetree/removeDocByID\\\", {\\\"id\\\": doc_id})\\n+\\n+ def move_docs(self, from_paths: list[str], to_notebook: str, to_path: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocs\\\", {\\n+ \\\"fromPaths\\\": from_paths, \\\"toNotebook\\\": to_notebook, \\\"toPath\\\": to_path,\\n+ })\\n+\\n+ def move_docs_by_id(self, from_ids: list[str], to_id: str) -> None:\\n+ self._post(\\\"/api/filetree/moveDocsByID\\\", {\\\"fromIDs\\\": from_ids, \\\"toID\\\": to_id})\\n+\\n+ def get_hpath_by_id(self, block_id: str) -> str:\\n+ return self._post(\\\"/api/filetree/getHPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_path_by_id(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/filetree/getPathByID\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_ids_by_hpath(self, notebook_id: str, path: str) -> list[str]:\\n+ return self._post(\\\"/api/filetree/getIDsByHPath\\\", {\\\"notebook\\\": notebook_id, \\\"path\\\": path})\\n+\\n+ def list_docs_by_path(self, notebook_id: str, path: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocsByPath\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxListCount\\\": 0,\\n+ })\\n+\\n+ def list_doc_tree(self, notebook_id: str, path: str = \\\"/\\\", max_depth: int = -1, sort: int = 0) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/listDocTree\\\", {\\n+ \\\"notebook\\\": notebook_id, \\\"path\\\": path, \\\"maxDepth\\\": max_depth, \\\"sort\\\": sort,\\n+ })\\n+\\n+ def search_docs(self, keyword: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/filetree/searchDocs\\\", {\\\"k\\\": keyword})\\n+\\n+ def create_daily_note(self, notebook_id: str) -> dict[str, Any]:\\n+ return self._post(\\\"/api/filetree/createDailyNote\\\", {\\\"notebook\\\": notebook_id})\\n+\\n+ # ── Block API ──────────────────────────────────────────────────────\\n+\\n+ def insert_block(self, data_type: str, data: str,\\n+ parent_id: str = \\\"\\\", previous_id: str = \\\"\\\", next_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"dataType\\\": data_type, \\\"data\\\": data}\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if next_id:\\n+ params[\\\"nextID\\\"] = next_id\\n+ return self._post(\\\"/api/block/insertBlock\\\", params)\\n+\\n+ def prepend_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/prependBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def append_block(self, data_type: str, data: str, parent_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/appendBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"parentID\\\": parent_id,\\n+ })\\n+\\n+ def update_block(self, data_type: str, data: str, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/updateBlock\\\", {\\n+ \\\"dataType\\\": data_type, \\\"data\\\": data, \\\"id\\\": block_id,\\n+ })\\n+\\n+ def delete_block(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/deleteBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def move_block(self, block_id: str, previous_id: str = \\\"\\\", parent_id: str = \\\"\\\") -> list[dict[str, Any]]:\\n+ params = {\\\"id\\\": block_id}\\n+ if previous_id:\\n+ params[\\\"previousID\\\"] = previous_id\\n+ if parent_id:\\n+ params[\\\"parentID\\\"] = parent_id\\n+ return self._post(\\\"/api/block/moveBlock\\\", params)\\n+\\n+ def fold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/foldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def unfold_block(self, block_id: str) -> None:\\n+ self._post(\\\"/api/block/unfoldBlock\\\", {\\\"id\\\": block_id})\\n+\\n+ def get_block_kramdown(self, block_id: str) -> str:\\n+ data = self._post(\\\"/api/block/getBlockKramdown\\\", {\\\"id\\\": block_id})\\n+ return data.get(\\\"kramdown\\\", \\\"\\\")\\n+\\n+ def get_child_blocks(self, block_id: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/block/getChildBlocks\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── Attribute API ──────────────────────────────────────────────────\\n+\\n+ def set_block_attrs(self, block_id: str, attrs: dict[str, str]) -> None:\\n+ self._post(\\\"/api/attr/setBlockAttrs\\\", {\\\"id\\\": block_id, \\\"attrs\\\": attrs})\\n+\\n+ def get_block_attrs(self, block_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/attr/getBlockAttrs\\\", {\\\"id\\\": block_id})\\n+\\n+ # ── SQL Query API ──────────────────────────────────────────────────\\n+\\n+ def query_sql(self, stmt: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/query/sql\\\", {\\\"stmt\\\": stmt})\\n+\\n+ # ── Search API ─────────────────────────────────────────────────────\\n+\\n+ def search_blocks(self, query: str) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/search/fullTextSearchBlock\\\", {\\\"query\\\": query})\\n+\\n+ def search_tag(self, tag: str = \\\"\\\") -> list[str]:\\n+ \\\"\\\"\\\"Search tags. Returns list of tag name strings.\\\"\\\"\\\"\\n+ data = self._post(\\\"/api/search/searchTag\\\", {\\\"k\\\": tag})\\n+ if isinstance(data, dict):\\n+ return data.get(\\\"tags\\\", [])\\n+ return data or []\\n+\\n+ def find_replace(self, keyword: str, replacement: str, ids: list[str]) -> None:\\n+ \\\"\\\"\\\"Search and replace text in blocks by ID.\\\"\\\"\\\"\\n+ self._post(\\\"/api/search/findReplace\\\", {\\n+ \\\"k\\\": keyword, \\\"r\\\": replacement, \\\"ids\\\": ids,\\n+ })\\n+\\n+ # ── Export API ─────────────────────────────────────────────────────\\n+\\n+ def export_md_content(self, doc_id: str) -> dict[str, str]:\\n+ return self._post(\\\"/api/export/exportMdContent\\\", {\\\"id\\\": doc_id})\\n+\\n+ def export_resources(self, paths: list[str], name: str = \\\"\\\") -> str:\\n+ params = {\\\"paths\\\": paths}\\n+ if name:\\n+ params[\\\"name\\\"] = name\\n+ data = self._post(\\\"/api/export/exportResources\\\", params)\\n+ return data.get(\\\"path\\\", \\\"\\\")\\n+\\n+ # ── Tag API ────────────────────────────────────────────────────────\\n+\\n+ def get_tags(self) -> list[dict[str, Any]]:\\n+ return self._post(\\\"/api/tag/getTag\\\", {\\\"ignoreMaxListHint\\\": True})\\n+\\n+ # ── System API ─────────────────────────────────────────────────────\\n+\\n+ def get_version(self) -> str:\\n+ return self._post(\\\"/api/system/version\\\")\\n+\\n+ def get_current_time(self) -> int:\\n+ return self._post(\\\"/api/system/currentTime\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Handle prompt interrupts before leaving REPL**\\n\\nWhen users exit the REPL with Ctrl-D or Ctrl-C, `skin.get_input()`/`input()` raises `EOFError` or `KeyboardInterrupt` here before the later `quit` branch and before the `_dispatch_repl` `try`, so the loop unwinds without `obj.session.flush()` or the goodbye path. In sessions where commands updated the current notebook/document, those dirty session changes are lost and users see an exception-style exit; catch these prompt interrupts and route them through the same flush/break path as `quit`.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\",\n \"hunk\": \"@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\",\n \"resolving_sha\": \"59e9f7bc2d5a2cd8ce91fc4d64905908428886ae\",\n \"resolving_diff\": \"diff --git a/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\nnew file mode 100644\\nindex 000000000..de4d1f345\\n--- /dev/null\\n+++ b/siyuan/agent-harness/cli_anything/siyuan/siyuan_cli.py\\n@@ -0,0 +1,802 @@\\n+\\\"\\\"\\\"cli-anything-siyuan — SiYuan (思源笔记) CLI harness.\\n+\\n+Connects to a running SiYuan kernel via its HTTP API and provides\\n+commands for notebooks, documents, blocks, search, and export.\\n+\\\"\\\"\\\"\\n+\\n+import json\\n+import os\\n+import shlex\\n+import sys\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.siyuan.core.client import (\\n+ SiYuanClient,\\n+ SiYuanClientError,\\n+ SiYuanConfig,\\n+ load_config,\\n+)\\n+from cli_anything.siyuan.core.session import SessionManager\\n+\\n+\\n+def _read_stdin() -> str:\\n+ \\\"\\\"\\\"Read stdin as raw bytes and decode as UTF-8 (with BOM handling).\\n+\\n+ PowerShell pipes text using the console code page (e.g. GBK on Chinese\\n+ Windows), which mangles CJK characters before Python sees them. Reading\\n+ raw bytes then decoding as UTF-8-sig is the most robust approach.\\n+ \\\"\\\"\\\"\\n+ if sys.stdin.isatty():\\n+ raise click.UsageError(\\n+ \\\"stdin pipe expected (e.g. echo 'content' | sy block insert --parent pid -)\\\"\\n+ )\\n+ raw = sys.stdin.buffer.read()\\n+ try:\\n+ return raw.decode('utf-8-sig')\\n+ except UnicodeDecodeError:\\n+ return raw.decode('utf-8-sig', errors='replace')\\n+\\n+\\n+# ── Click context ─────────────────────────────────────────────────────\\n+\\n+class SiYuanContext:\\n+ def __init__(self, client: SiYuanClient | None = None,\\n+ session: SessionManager | None = None,\\n+ json_output: bool = False):\\n+ self.json_output = json_output\\n+ self.client = client\\n+ self.session = session or SessionManager()\\n+\\n+\\n+class _CatchErrors(click.Group):\\n+ \\\"\\\"\\\"Click Group that converts SiYuanClientError to clean CLI errors.\\\"\\\"\\\"\\n+\\n+ def invoke(self, ctx: click.Context) -> object:\\n+ try:\\n+ return super().invoke(ctx)\\n+ except SiYuanClientError as e:\\n+ click.echo(f\\\"Error: {e}\\\", err=True)\\n+ sys.exit(1)\\n+\\n+\\n+@click.group(cls=_CatchErrors, invoke_without_command=True)\\n+@click.option(\\\"--json\\\", \\\"json_output\\\", is_flag=True, help=\\\"Output in JSON format\\\")\\n+@click.option(\\\"--host\\\", default=\\\"\\\", help=\\\"SiYuan host (default: 127.0.0.1)\\\")\\n+@click.option(\\\"--port\\\", default=0, type=int, help=\\\"SiYuan port (default: 6806)\\\")\\n+@click.option(\\\"--token\\\", default=\\\"\\\", help=\\\"SiYuan API token\\\")\\n+@click.option(\\\"--config\\\", \\\"config_path\\\", default=\\\"\\\", help=\\\"Config file path\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, json_output: bool, host: str, port: int,\\n+ token: str, config_path: str):\\n+ # Force UTF-8 output to handle CJK characters on Windows\\n+ for stream in (sys.stdout, sys.stderr):\\n+ if hasattr(stream, 'reconfigure'):\\n+ stream.reconfigure(encoding='utf-8')\\n+\\n+ \\\"\\\"\\\"CLI for SiYuan (思源笔记) — interact with your knowledge base.\\n+\\n+ Connects to a running SiYuan instance via its HTTP API.\\n+ Default: http://127.0.0.1:6806\\n+\\n+ Configure connection via ~/.siyuan-cli.json, env vars\\n+ (SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN), or CLI flags.\\n+ \\\"\\\"\\\"\\n+ session = SessionManager()\\n+ session.load()\\n+ cfg = load_config(config_path or None)\\n+ if host or port or token:\\n+ cfg = SiYuanConfig(\\n+ host=host or cfg.host,\\n+ port=port or cfg.port,\\n+ token=token or cfg.token,\\n+ )\\n+ client = SiYuanClient(cfg)\\n+ ctx.obj = SiYuanContext(client=client, session=session, json_output=json_output)\\n+\\n+ if ctx.invoked_subcommand is None:\\n+ if not client.ping():\\n+ click.echo(\\\"Error: Cannot connect to SiYuan. Is it running?\\\", err=True)\\n+ click.echo(\\\" Configure via: --host --port --token\\\", err=True)\\n+ click.echo(\\\" Or set: SIYUAN_HOST, SIYUAN_PORT, SIYUAN_TOKEN\\\", err=True)\\n+ sys.exit(1)\\n+ ctx.invoke(repl)\\n+\\n+\\n+def _walk_tree(items: list[dict], depth: int = 0) -> list[dict]:\\n+ \\\"\\\"\\\"Recursively flatten a doc tree, setting depth on each entry.\\n+\\n+ Returns new dicts; does not mutate the originals.\\n+ \\\"\\\"\\\"\\n+ result: list[dict] = []\\n+ for t in items:\\n+ entry = {**t, \\\"depth\\\": depth}\\n+ result.append(entry)\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ result.extend(_walk_tree(children, depth + 1))\\n+ return result\\n+\\n+\\n+# ── REPL ───────────────────────────────────────────────────────────────\\n+\\n+def _build_repl_commands() -> dict[str, str]:\\n+ return {\\n+ \\\"notebook list\\\": \\\"List all notebooks\\\",\\n+ \\\"notebook create <name>\\\": \\\"Create a notebook\\\",\\n+ \\\"notebook rename <id> <name>\\\": \\\"Rename a notebook\\\",\\n+ \\\"notebook remove <id>\\\": \\\"Remove a notebook\\\",\\n+ \\\"doc create <notebook> <path>\\\": \\\"Create a document with optional --md content\\\",\\n+ \\\"doc list <notebook> <path>\\\": \\\"List documents at path\\\",\\n+ \\\"doc tree <notebook>\\\": \\\"List full document tree\\\",\\n+ \\\"doc get <id>\\\": \\\"Get document info by ID\\\",\\n+ \\\"block insert <parent> <data>\\\": \\\"Insert a block (use '-' for stdin)\\\",\\n+ \\\"block update <id> <data>\\\": \\\"Update a block (use '-' for stdin)\\\",\\n+ \\\"block delete <id>\\\": \\\"Delete a block\\\",\\n+ \\\"block get <id>\\\": \\\"Get block kramdown source\\\",\\n+ \\\"sql <stmt>\\\": \\\"Execute SQL query\\\",\\n+ \\\"search <query>\\\": \\\"Full-text search\\\",\\n+ \\\"export md <doc-id>\\\": \\\"Export doc as Markdown\\\",\\n+ \\\"status\\\": \\\"Show connection and session status\\\",\\n+ \\\"help\\\": \\\"Show this help\\\",\\n+ \\\"quit\\\": \\\"Exit REPL\\\",\\n+ }\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context):\\n+ \\\"\\\"\\\"Start interactive REPL mode.\\\"\\\"\\\"\\n+ from cli_anything.siyuan.utils.repl_skin import ReplSkin\\n+\\n+ obj: SiYuanContext = ctx.obj\\n+\\n+ try:\\n+ kernel_version = obj.client.get_version()\\n+ except SiYuanClientError:\\n+ kernel_version = \\\"?\\\"\\n+ skin = ReplSkin(\\\"siyuan\\\", version=kernel_version)\\n+ skin.print_banner()\\n+\\n+ pt_session = skin.create_prompt_session()\\n+ commands = _build_repl_commands()\\n+\\n+ state = obj.session.state\\n+\\n+ while True:\\n+ ctx_str = \\\"\\\"\\n+ if state.current_notebook_name:\\n+ ctx_str = state.current_notebook_name\\n+ user_input = skin.get_input(\\n+ pt_session,\\n+ project_name=state.current_doc_path or \\\"\\\",\\n+ modified=False,\\n+ context=ctx_str,\\n+ )\\n+\\n+ if not user_input:\\n+ continue\\n+\\n+ if user_input in (\\\"quit\\\", \\\"exit\\\", \\\"q\\\"):\\n+ obj.session.flush()\\n+ break\\n+\\n+ if user_input == \\\"help\\\":\\n+ skin.help(commands)\\n+ continue\\n+\\n+ if user_input == \\\"status\\\":\\n+ connected = obj.client.ping()\\n+ skin.status_block({\\n+ \\\"Connected\\\": str(connected),\\n+ \\\"Notebook\\\": state.current_notebook_name or \\\"(none)\\\",\\n+ \\\"Document\\\": state.current_doc_path or \\\"(none)\\\",\\n+ }, title=\\\"Status\\\")\\n+ continue\\n+\\n+ try:\\n+ _dispatch_repl(skin, obj, user_input)\\n+ except SiYuanClientError as e:\\n+ skin.error(str(e))\\n+ except Exception as e:\\n+ skin.error(f\\\"Error: {e}\\\")\\n+\\n+ skin.print_goodbye()\\n+\\n+\\n+def _dispatch_repl(skin: Any, ctx: SiYuanContext, cmd: str) -> None:\\n+ \\\"\\\"\\\"Parse REPL command and route to the appropriate handler.\\\"\\\"\\\"\\n+ parts = shlex.split(cmd.strip())\\n+ if not parts:\\n+ return\\n+\\n+ json_mode = \\\"--json\\\" in parts\\n+ parts = [p for p in parts if p != \\\"--json\\\"]\\n+\\n+ client = ctx.client\\n+ session = ctx.session\\n+\\n+ command = parts[0]\\n+ if command == \\\"notebook\\\":\\n+ _handle_notebook_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"doc\\\":\\n+ _handle_doc_repl(skin, client, session, parts, json_mode)\\n+ elif command == \\\"block\\\":\\n+ _handle_block_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"sql\\\" and len(parts) >= 2:\\n+ _handle_sql_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"search\\\" and len(parts) >= 2:\\n+ _handle_search_repl(skin, client, parts, json_mode)\\n+ elif command == \\\"export\\\":\\n+ _handle_export_repl(skin, client, parts, json_mode)\\n+ else:\\n+ skin.error(f\\\"Unknown command: {parts[0]}\\\")\\n+\\n+\\n+# ── REPL sub-handlers ──────────────────────────────────────────────────\\n+\\n+def _handle_notebook_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: notebook <list|create|rename|remove>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"list\\\":\\n+ notebooks = client.list_notebooks()\\n+ if json_mode:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Icon\\\", \\\"Closed\\\"],\\n+ [[n[\\\"id\\\"], n[\\\"name\\\"], n.get(\\\"icon\\\", \\\"\\\"), str(n.get(\\\"closed\\\", \\\"\\\"))]\\n+ for n in notebooks])\\n+ elif sub == \\\"create\\\" and len(parts) >= 3:\\n+ name = \\\" \\\".join(parts[2:])\\n+ nb = client.create_notebook(name)\\n+ session.update(current_notebook_id=nb[\\\"id\\\"], current_notebook_name=nb[\\\"name\\\"])\\n+ client.open_notebook(nb[\\\"id\\\"])\\n+ skin.success(f'Created notebook: {nb[\\\"name\\\"]} ({nb[\\\"id\\\"]})')\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_notebook(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_notebook(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ else:\\n+ skin.error(\\\"Invalid notebook command\\\")\\n+\\n+\\n+def _handle_doc_repl(skin: Any, client: SiYuanClient,\\n+ session: SessionManager, parts: list[str],\\n+ json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: doc <create|list|tree|get|rename|remove|export>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"create\\\" and len(parts) >= 4:\\n+ md = \\\"\\\"\\n+ if \\\"--md\\\" in parts:\\n+ idx = parts.index(\\\"--md\\\") + 1\\n+ if idx < len(parts):\\n+ md = parts[idx]\\n+ parts = parts[:parts.index(\\\"--md\\\")]\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ nb_id = parts[2]\\n+ doc_path = parts[3]\\n+ doc_id = client.create_doc_with_md(nb_id, doc_path, md)\\n+ session.update(current_doc_id=doc_id, current_doc_path=doc_path)\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Created doc: {doc_id}\\\")\\n+ elif sub == \\\"list\\\" and len(parts) >= 4:\\n+ docs = client.list_docs_by_path(parts[2], parts[3])\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Type\\\"],\\n+ [[d.get(\\\"id\\\", \\\"\\\"), d.get(\\\"name\\\", \\\"\\\"), d.get(\\\"type\\\", \\\"\\\")]\\n+ for d in items])\\n+ elif sub == \\\"tree\\\" and len(parts) >= 3:\\n+ tree = client.list_doc_tree(parts[2])\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if json_mode:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Name\\\", \\\"Path\\\"],\\n+ [[t.get(\\\"id\\\", \\\"\\\"), \\\" \\\" * t.get(\\\"depth\\\", 0) + t.get(\\\"name\\\", \\\"\\\"), t.get(\\\"path\\\", \\\"\\\")]\\n+ for t in _walk_tree(items)])\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ hpath = client.get_hpath_by_id(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ skin.success(f\\\"Path: {hpath}\\\")\\n+ elif sub == \\\"rename\\\" and len(parts) >= 4:\\n+ client.rename_doc_by_id(parts[2], \\\" \\\".join(parts[3:]))\\n+ skin.success(\\\"Renamed\\\")\\n+ elif sub == \\\"remove\\\" and len(parts) >= 3:\\n+ client.remove_doc_by_id(parts[2])\\n+ skin.success(\\\"Removed\\\")\\n+ elif sub == \\\"export\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Invalid doc command\\\")\\n+\\n+\\n+def _handle_block_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if len(parts) < 2:\\n+ skin.error(\\\"Usage: block <insert|prepend|append|update|delete|get|child>\\\")\\n+ return\\n+ sub = parts[1]\\n+ if sub == \\\"insert\\\":\\n+ if len(parts) < 4:\\n+ skin.error(\\\"Usage: block insert <parent_id> <data>\\\")\\n+ return\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = client.insert_block(\\\"markdown\\\", data, parent_id=parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ skin.success(\\\"Block inserted\\\")\\n+ elif sub == \\\"prepend\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.prepend_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block prepended\\\")\\n+ elif sub == \\\"append\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.append_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block appended\\\")\\n+ elif sub == \\\"update\\\" and len(parts) >= 4:\\n+ data = parts[3]\\n+ if data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ client.update_block(\\\"markdown\\\", data, parts[2])\\n+ skin.success(\\\"Block updated\\\")\\n+ elif sub == \\\"delete\\\" and len(parts) >= 3:\\n+ client.delete_block(parts[2])\\n+ skin.success(\\\"Block deleted\\\")\\n+ elif sub == \\\"get\\\" and len(parts) >= 3:\\n+ kramdown = client.get_block_kramdown(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+ elif sub == \\\"child\\\" and len(parts) >= 3:\\n+ children = client.get_child_blocks(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Type\\\", \\\"SubType\\\"],\\n+ [[c.get(\\\"id\\\", \\\"\\\"), c.get(\\\"type\\\", \\\"\\\"), c.get(\\\"subType\\\", \\\"\\\")]\\n+ for c in children])\\n+ else:\\n+ skin.error(\\\"Invalid block command\\\")\\n+\\n+\\n+def _handle_sql_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ stmt = \\\" \\\".join(parts[1:])\\n+ results = client.query_sql(stmt)\\n+ if json_mode:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ headers = list(results[0].keys())\\n+ rows = [[str(r.get(h, \\\"\\\")) for h in headers] for r in results]\\n+ skin.table(headers, rows)\\n+\\n+\\n+def _handle_search_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ query = \\\" \\\".join(parts[1:])\\n+ data = client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if json_mode:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ skin.info(\\\"No results\\\")\\n+ else:\\n+ skin.table([\\\"ID\\\", \\\"Content\\\"],\\n+ [[r.get(\\\"id\\\", \\\"\\\"), r.get(\\\"content\\\", \\\"\\\")[:80]] for r in blocks])\\n+\\n+\\n+def _handle_export_repl(skin: Any, client: SiYuanClient,\\n+ parts: list[str], json_mode: bool) -> None:\\n+ if parts[1] == \\\"md\\\" and len(parts) >= 3:\\n+ md = client.export_md_content(parts[2])\\n+ if json_mode:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ skin.section(md.get(\\\"hPath\\\", \\\"\\\"))\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+ else:\\n+ skin.error(\\\"Usage: export md <doc-id>\\\")\\n+\\n+\\n+# ── Notebook commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def notebook():\\n+ \\\"\\\"\\\"Manage notebooks (笔记本).\\\"\\\"\\\"\\n+\\n+\\n+@notebook.command(\\\"list\\\")\\n+@click.pass_obj\\n+def notebook_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all notebooks.\\\"\\\"\\\"\\n+ notebooks = ctx.client.list_notebooks()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(notebooks, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Closed':<8}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for nb in notebooks:\\n+ click.echo(f\\\"{nb['id']:<30} {nb['name']:<30} {str(nb.get('closed', '')):<8}\\\")\\n+\\n+\\n+@notebook.command(\\\"create\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_create(ctx: SiYuanContext, name: str):\\n+ \\\"\\\"\\\"Create a new notebook.\\\"\\\"\\\"\\n+ nb = ctx.client.create_notebook(name)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(nb, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created notebook: {nb['name']} ({nb['id']})\\\")\\n+\\n+\\n+@notebook.command(\\\"remove\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_remove(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Remove a notebook by ID.\\\"\\\"\\\"\\n+ ctx.client.remove_notebook(notebook_id)\\n+ click.echo(f\\\"Removed notebook: {notebook_id}\\\")\\n+\\n+\\n+@notebook.command(\\\"rename\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.pass_obj\\n+def notebook_rename(ctx: SiYuanContext, notebook_id: str, name: str):\\n+ \\\"\\\"\\\"Rename a notebook.\\\"\\\"\\\"\\n+ ctx.client.rename_notebook(notebook_id, name)\\n+ click.echo(f\\\"Renamed notebook {notebook_id} to: {name}\\\")\\n+\\n+\\n+@notebook.command(\\\"open\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.pass_obj\\n+def notebook_open(ctx: SiYuanContext, notebook_id: str):\\n+ \\\"\\\"\\\"Open a notebook.\\\"\\\"\\\"\\n+ ctx.client.open_notebook(notebook_id)\\n+ name = notebook_id\\n+ for nb in ctx.client.list_notebooks():\\n+ if nb.get(\\\"id\\\") == notebook_id:\\n+ name = nb.get(\\\"name\\\", notebook_id)\\n+ break\\n+ ctx.session.update(current_notebook_id=notebook_id, current_notebook_name=name)\\n+ ctx.session.flush()\\n+ click.echo(f\\\"Opened notebook: {name} ({notebook_id})\\\")\\n+\\n+\\n+# ── Document commands ──────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def doc():\\n+ \\\"\\\"\\\"Manage documents (文档).\\\"\\\"\\\"\\n+\\n+\\n+@doc.command(\\\"create\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\")\\n+@click.option(\\\"--md\\\", default=\\\"\\\", help=\\\"Markdown content. Use '-' to read from stdin.\\\")\\n+@click.pass_obj\\n+def doc_create(ctx: SiYuanContext, notebook_id: str, path: str, md: str):\\n+ \\\"\\\"\\\"Create a document with optional Markdown content.\\n+\\n+ To avoid shell escaping issues with special characters\\n+ (backticks, quotes, parentheses), pipe Markdown via stdin:\\n+ echo \\\"## Title\\\" | sy doc create nb1 /test --md -\\n+ \\\"\\\"\\\"\\n+ if md == \\\"-\\\":\\n+ md = _read_stdin()\\n+ doc_id = ctx.client.create_doc_with_md(notebook_id, path, md)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"id\\\": doc_id}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Created doc: {doc_id}\\\")\\n+\\n+\\n+@doc.command(\\\"list\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.argument(\\\"path\\\", default=\\\"/\\\")\\n+@click.pass_obj\\n+def doc_list(ctx: SiYuanContext, notebook_id: str, path: str):\\n+ \\\"\\\"\\\"List documents at a path.\\\"\\\"\\\"\\n+ docs = ctx.client.list_docs_by_path(notebook_id, path)\\n+ items = docs.get(\\\"files\\\", []) if isinstance(docs, dict) else docs\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"{'ID':<30} {'Name':<30} {'Type':<10}\\\")\\n+ click.echo(\\\"-\\\" * 70)\\n+ for d in items:\\n+ click.echo(f\\\"{d.get('id', ''):<30} {d.get('name', ''):<30} {d.get('type', ''):<10}\\\")\\n+\\n+\\n+@doc.command(\\\"tree\\\")\\n+@click.argument(\\\"notebook_id\\\")\\n+@click.option(\\\"--path\\\", default=\\\"/\\\", help=\\\"Root path\\\")\\n+@click.option(\\\"--depth\\\", default=-1, type=int, help=\\\"Max depth\\\")\\n+@click.pass_obj\\n+def doc_tree(ctx: SiYuanContext, notebook_id: str, path: str, depth: int):\\n+ \\\"\\\"\\\"List document tree.\\\"\\\"\\\"\\n+ tree = ctx.client.list_doc_tree(notebook_id, path=path, max_depth=depth)\\n+ if isinstance(tree, dict):\\n+ items = tree.get(\\\"files\\\") or tree.get(\\\"tree\\\") or []\\n+ else:\\n+ items = tree\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(items, ensure_ascii=False))\\n+ else:\\n+ for t in _walk_tree(items):\\n+ indent = \\\" \\\" * t.get(\\\"depth\\\", 0)\\n+ click.echo(f\\\"{indent}{t.get('name', '')} ({t.get('id', '')})\\\")\\n+\\n+\\n+@doc.command(\\\"get\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_get(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Get document info by ID.\\\"\\\"\\\"\\n+ hpath = ctx.client.get_hpath_by_id(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"hpath\\\": hpath}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"Path: {hpath}\\\")\\n+\\n+\\n+@doc.command(\\\"rename\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.argument(\\\"title\\\")\\n+@click.pass_obj\\n+def doc_rename(ctx: SiYuanContext, doc_id: str, title: str):\\n+ \\\"\\\"\\\"Rename a document.\\\"\\\"\\\"\\n+ ctx.client.rename_doc_by_id(doc_id, title)\\n+ click.echo(f\\\"Renamed {doc_id} to: {title}\\\")\\n+\\n+\\n+@doc.command(\\\"remove\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def doc_remove(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Remove a document.\\\"\\\"\\\"\\n+ ctx.client.remove_doc_by_id(doc_id)\\n+ click.echo(f\\\"Removed: {doc_id}\\\")\\n+\\n+\\n+# ── Block commands ─────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def block():\\n+ \\\"\\\"\\\"Manage blocks (内容块).\\\"\\\"\\\"\\n+\\n+\\n+@block.command(\\\"insert\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--previous\\\", default=\\\"\\\", help=\\\"Previous block ID\\\")\\n+@click.option(\\\"--parent\\\", default=\\\"\\\", help=\\\"Parent block ID\\\")\\n+@click.option(\\\"--next\\\", \\\"next_\\\", default=\\\"\\\", help=\\\"Next block ID\\\")\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type (markdown/dom)\\\")\\n+@click.pass_obj\\n+def block_insert(ctx: SiYuanContext, data: str | None, previous: str, parent: str, next_: str, data_type: str):\\n+ \\\"\\\"\\\"Insert a block. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not parent and not previous and not next_:\\n+ raise click.UsageError(\\\"An anchor is required: --parent, --previous, or --next\\\")\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ result = ctx.client.insert_block(data_type, data, parent_id=parent, previous_id=previous, next_id=next_)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(result, ensure_ascii=False))\\n+ else:\\n+ click.echo(\\\"Block inserted\\\")\\n+\\n+\\n+@block.command(\\\"update\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.argument(\\\"data\\\", required=False)\\n+@click.option(\\\"--data-type\\\", default=\\\"markdown\\\", help=\\\"Data type\\\")\\n+@click.pass_obj\\n+def block_update(ctx: SiYuanContext, block_id: str, data: str | None, data_type: str):\\n+ \\\"\\\"\\\"Update a block's content. Data reads from stdin when '-' or omitted.\\\"\\\"\\\"\\n+ if not data or data == \\\"-\\\":\\n+ data = _read_stdin()\\n+ ctx.client.update_block(data_type, data, block_id)\\n+ click.echo(f\\\"Updated block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"delete\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_delete(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Delete a block.\\\"\\\"\\\"\\n+ ctx.client.delete_block(block_id)\\n+ click.echo(f\\\"Deleted block: {block_id}\\\")\\n+\\n+\\n+@block.command(\\\"get\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_get(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get block kramdown source.\\\"\\\"\\\"\\n+ kramdown = ctx.client.get_block_kramdown(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"kramdown\\\": kramdown}, ensure_ascii=False))\\n+ else:\\n+ click.echo(kramdown)\\n+\\n+\\n+@block.command(\\\"children\\\")\\n+@click.argument(\\\"block_id\\\")\\n+@click.pass_obj\\n+def block_children(ctx: SiYuanContext, block_id: str):\\n+ \\\"\\\"\\\"Get child blocks.\\\"\\\"\\\"\\n+ children = ctx.client.get_child_blocks(block_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(children, ensure_ascii=False))\\n+ else:\\n+ for c in children:\\n+ click.echo(f\\\"{c.get('id', ''):<30} {c.get('type', ''):<8} {c.get('subType', '')}\\\")\\n+\\n+\\n+# ── SQL command ────────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"stmt\\\")\\n+@click.pass_obj\\n+def sql(ctx: SiYuanContext, stmt: str):\\n+ \\\"\\\"\\\"Execute a SQL query on the block database.\\n+\\n+ Example: sql \\\"SELECT * FROM blocks WHERE content LIKE '%keyword%' LIMIT 10\\\"\\n+ \\\"\\\"\\\"\\n+ results = ctx.client.query_sql(stmt)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(results, ensure_ascii=False))\\n+ elif not results:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in results:\\n+ click.echo(json.dumps(r, ensure_ascii=False))\\n+\\n+\\n+# ── Search commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.argument(\\\"query\\\")\\n+@click.pass_obj\\n+def search(ctx: SiYuanContext, query: str):\\n+ \\\"\\\"\\\"Full-text search across all blocks.\\\"\\\"\\\"\\n+ data = ctx.client.search_blocks(query)\\n+ blocks = data.get(\\\"blocks\\\", []) if isinstance(data, dict) else data\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(blocks, ensure_ascii=False))\\n+ elif not blocks:\\n+ click.echo(\\\"No results\\\")\\n+ else:\\n+ for r in blocks[:20]:\\n+ click.echo(f\\\"- {r.get('id', '')}: {r.get('content', '')[:120]}\\\")\\n+\\n+\\n+# ── Export commands ────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def export():\\n+ \\\"\\\"\\\"Export content from SiYuan.\\\"\\\"\\\"\\n+\\n+\\n+@export.command(\\\"md\\\")\\n+@click.argument(\\\"doc_id\\\")\\n+@click.pass_obj\\n+def export_md(ctx: SiYuanContext, doc_id: str):\\n+ \\\"\\\"\\\"Export a document as Markdown.\\\"\\\"\\\"\\n+ md = ctx.client.export_md_content(doc_id)\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(md, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"# {md.get('hPath', '')}\\\")\\n+ click.echo(\\\"\\\")\\n+ click.echo(md.get(\\\"content\\\", \\\"\\\"))\\n+\\n+\\n+# ── System commands ────────────────────────────────────────────────────\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def version(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show SiYuan kernel version.\\\"\\\"\\\"\\n+ ver = ctx.client.get_version()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps({\\\"version\\\": ver}, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\"SiYuan version: {ver}\\\")\\n+\\n+\\n+@cli.command()\\n+@click.pass_obj\\n+def status(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"Show connection and session status.\\\"\\\"\\\"\\n+ connected = ctx.client.ping()\\n+ siyuan_ver = ctx.client.get_version() if connected else \\\"\\\"\\n+ session = ctx.session\\n+ state = session.state\\n+\\n+ info = {\\n+ \\\"connected\\\": connected,\\n+ \\\"siyuan_version\\\": siyuan_ver,\\n+ \\\"host\\\": ctx.client.config.host,\\n+ \\\"port\\\": ctx.client.config.port,\\n+ \\\"current_notebook\\\": state.current_notebook_name or \\\"\\\",\\n+ \\\"current_doc\\\": state.current_doc_path or \\\"\\\",\\n+ }\\n+\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(info, ensure_ascii=False))\\n+ else:\\n+ click.echo(f\\\" Connected: {info['connected']}\\\")\\n+ click.echo(f\\\" SiYuan: v{info['siyuan_version']}\\\")\\n+ click.echo(f\\\" Host: {info['host']}:{info['port']}\\\")\\n+ click.echo(f\\\" Notebook: {info['current_notebook']}\\\")\\n+ click.echo(f\\\" Document: {info['current_doc']}\\\")\\n+\\n+\\n+# ── Tag commands ───────────────────────────────────────────────────────\\n+\\n+@cli.group()\\n+def tag():\\n+ \\\"\\\"\\\"Manage tags (标签).\\\"\\\"\\\"\\n+\\n+\\n+def _print_tags(tags: list[dict], indent: int = 0) -> None:\\n+ \\\"\\\"\\\"Recursively print tags with hierarchical indentation.\\\"\\\"\\\"\\n+ pad = \\\" \\\" * indent\\n+ for t in tags:\\n+ if indent == 0:\\n+ click.echo(f\\\"{t.get('name', ''):<30} ({t.get('count', 0)})\\\")\\n+ else:\\n+ click.echo(f\\\"{pad}{t.get('name', ''):<{30 - 2 * indent}} ({t.get('count', 0)})\\\")\\n+ children = t.get(\\\"children\\\")\\n+ if children:\\n+ _print_tags(children, indent + 1)\\n+\\n+\\n+@tag.command(\\\"list\\\")\\n+@click.pass_obj\\n+def tag_list(ctx: SiYuanContext):\\n+ \\\"\\\"\\\"List all tags (including nested tags).\\\"\\\"\\\"\\n+ tags = ctx.client.get_tags()\\n+ if ctx.json_output:\\n+ click.echo(json.dumps(tags, ensure_ascii=False))\\n+ else:\\n+ _print_tags(tags)\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":"diff --git a/siyuan/agent-harness/cli_anything/siyuan/tests/__init__.py b/siyuan/agent-harness/cli_anything/siyuan/tests/__init__.py\nnew file mode 100644\nindex 000000000..e69de29bb\ndiff --git a/siyuan/agent-harness/cli_anything/siyuan/tests/test_cli_commands.py b/siyuan/agent-harness/cli_anything/siyuan/tests/test_cli_commands.py\nnew file mode 100644\nindex 000000000..a97568510\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/tests/test_cli_commands.py\n@@ -0,0 +1,408 @@\n+\"\"\"Unit tests for cli-anything-siyuan CLI commands.\n+\n+Tests CLI output formatting using Click's CliRunner with mocked client.\n+No external dependencies or running SiYuan instance required.\n+\"\"\"\n+\n+import json\n+from unittest.mock import MagicMock, patch\n+\n+import pytest\n+from click.testing import CliRunner\n+\n+from cli_anything.siyuan.siyuan_cli import cli\n+\n+\n+@pytest.fixture\n+def runner():\n+ return CliRunner()\n+\n+\n+@pytest.fixture\n+def mock_ctx():\n+ \"\"\"Create a mock SiYuanContext with a mock client.\"\"\"\n+ ctx = MagicMock()\n+ ctx.json_output = False\n+ return ctx\n+\n+\n+# ── Search command ─────────────────────────────────────────────────────\n+\n+\n+class TestSearchCommand:\n+ def test_search_returns_blocks_list(self, runner, mock_ctx):\n+ \"\"\"search handles API returning list of blocks directly.\"\"\"\n+ mock_ctx.client.search_blocks.return_value = [\n+ {\"id\": \"b1\", \"content\": \"Dit模型训练结果如何\"},\n+ {\"id\": \"b2\", \"content\": \"训练完成，准确率90%\"},\n+ ]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"search\", \"Dit模型\"])\n+ assert result.exit_code == 0\n+ assert \"b1\" in result.output\n+ assert \"Dit模型训练结果如何\" in result.output\n+ assert \"b2\" in result.output\n+\n+ def test_search_returns_dict_with_blocks_key(self, runner, mock_ctx):\n+ \"\"\"search handles API returning dict with 'blocks' key (real SiYuan format).\n+\n+ This is the fix for KeyError: slice — real SiYuan API returns\n+ {\"blocks\": [...], \"rootBlocks\": {...}} not a flat list.\n+ \"\"\"\n+ mock_ctx.client.search_blocks.return_value = {\n+ \"blocks\": [\n+ {\"id\": \"b1\", \"content\": \"Dit模型训练完成\"},\n+ {\"id\": \"b2\", \"content\": \"loss=0.02\"},\n+ ],\n+ \"rootBlocks\": {},\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"search\", \"Dit模型\"])\n+ assert result.exit_code == 0\n+ assert \"b1\" in result.output\n+ assert \"Dit模型训练完成\" in result.output\n+\n+ def test_search_json_output(self, runner, mock_ctx):\n+ \"\"\"--json search returns raw data.\"\"\"\n+ mock_ctx.json_output = True\n+ mock_ctx.client.search_blocks.return_value = {\n+ \"blocks\": [{\"id\": \"b1\", \"content\": \"test\"}],\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"--json\", \"search\", \"test\"])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[0][\"id\"] == \"b1\"\n+\n+ def test_search_no_results(self, runner, mock_ctx):\n+ \"\"\"search shows 'No results' when empty list.\"\"\"\n+ mock_ctx.client.search_blocks.return_value = []\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"search\", \"nonexistent\"])\n+ assert result.exit_code == 0\n+ assert \"No results\" in result.output\n+\n+ def test_search_no_results_dict(self, runner, mock_ctx):\n+ \"\"\"search shows 'No results' when dict with empty blocks list.\"\"\"\n+ mock_ctx.client.search_blocks.return_value = {\"blocks\": [], \"rootBlocks\": {}}\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"search\", \"nonexistent\"])\n+ assert result.exit_code == 0\n+ assert \"No results\" in result.output\n+\n+\n+# ── Doc list command ───────────────────────────────────────────────────\n+\n+\n+class TestDocListCommand:\n+ def test_doc_list_returns_files(self, runner, mock_ctx):\n+ \"\"\"doc list handles API returning dict with 'files' key.\"\"\"\n+ mock_ctx.client.list_docs_by_path.return_value = {\n+ \"box\": \"nb1\",\n+ \"files\": [\n+ {\"id\": \"doc1\", \"name\": \"测试文档\", \"type\": \"d\"},\n+ {\"id\": \"doc2\", \"name\": \"笔记\", \"type\": \"d\"},\n+ ],\n+ \"path\": \"/\",\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"doc\", \"list\", \"nb1\"])\n+ assert result.exit_code == 0\n+ assert \"doc1\" in result.output\n+ assert \"测试文档\" in result.output\n+ assert \"doc2\" in result.output\n+\n+ def test_doc_list_empty(self, runner, mock_ctx):\n+ \"\"\"doc list handles empty files list.\"\"\"\n+ mock_ctx.client.list_docs_by_path.return_value = {\n+ \"box\": \"nb1\", \"files\": [], \"path\": \"/\",\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"doc\", \"list\", \"nb1\"])\n+ assert result.exit_code == 0\n+ # Should show header but no data rows\n+ assert \"ID\" in result.output\n+ assert \"Name\" in result.output\n+\n+ def test_doc_list_json(self, runner, mock_ctx):\n+ \"\"\"--json doc list returns raw files array.\"\"\"\n+ mock_ctx.json_output = True\n+ mock_ctx.client.list_docs_by_path.return_value = {\n+ \"box\": \"nb1\", \"files\": [{\"id\": \"doc1\", \"name\": \"Test\"}], \"path\": \"/\",\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"--json\", \"doc\", \"list\", \"nb1\"])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[0][\"id\"] == \"doc1\"\n+\n+\n+# ── Doc tree command ───────────────────────────────────────────────────\n+\n+\n+class TestDocTreeCommand:\n+ def test_doc_tree_returns_files(self, runner, mock_ctx):\n+ \"\"\"doc tree handles API returning dict with 'files' key.\"\"\"\n+ mock_ctx.client.list_doc_tree.return_value = {\n+ \"files\": [\n+ {\"id\": \"doc1\", \"name\": \"根文档\", \"depth\": 0},\n+ {\"id\": \"doc2\", \"name\": \"子文档\", \"depth\": 1},\n+ ],\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"doc\", \"tree\", \"nb1\"])\n+ assert result.exit_code == 0\n+ assert \"根文档\" in result.output\n+ assert \"子文档\" in result.output\n+\n+ def test_doc_tree_json(self, runner, mock_ctx):\n+ \"\"\"--json doc tree returns raw files array.\"\"\"\n+ mock_ctx.json_output = True\n+ mock_ctx.client.list_doc_tree.return_value = {\n+ \"files\": [{\"id\": \"doc1\", \"name\": \"Root\"}],\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"--json\", \"doc\", \"tree\", \"nb1\"])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[0][\"id\"] == \"doc1\"\n+\n+\n+# ── Notebook list command ──────────────────────────────────────────────\n+\n+\n+class TestNotebookListCommand:\n+ def test_notebook_list(self, runner, mock_ctx):\n+ \"\"\"notebook list returns formatted table.\"\"\"\n+ mock_ctx.client.list_notebooks.return_value = [\n+ {\"id\": \"nb1\", \"name\": \"工作笔记\", \"closed\": False},\n+ {\"id\": \"nb2\", \"name\": \"归档\", \"closed\": True},\n+ ]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"notebook\", \"list\"])\n+ assert result.exit_code == 0\n+ assert \"工作笔记\" in result.output\n+ assert \"nb1\" in result.output\n+\n+\n+# ── Tag list command ───────────────────────────────────────────────────\n+\n+\n+class TestTagListCommand:\n+ def test_tag_list(self, runner, mock_ctx):\n+ \"\"\"tag list shows tag names with counts.\"\"\"\n+ mock_ctx.client.get_tags.return_value = [\n+ {\"name\": \"AI\", \"count\": 5},\n+ {\"name\": \"Python\", \"count\": 12},\n+ {\"name\": \"笔记\", \"count\": 3},\n+ ]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"tag\", \"list\"])\n+ assert result.exit_code == 0\n+ assert \"AI\" in result.output\n+ assert \"5\" in result.output\n+ assert \"Python\" in result.output\n+ assert \"12\" in result.output\n+\n+\n+# ── SQL command ────────────────────────────────────────────────────────\n+\n+\n+class TestSQLCommand:\n+ def test_sql_query(self, runner, mock_ctx):\n+ \"\"\"sql returns query results.\"\"\"\n+ mock_ctx.client.query_sql.return_value = [\n+ {\"id\": \"b1\", \"content\": \"hello\"},\n+ {\"id\": \"b2\", \"content\": \"world\"},\n+ ]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"sql\", \"SELECT * FROM blocks\"])\n+ assert result.exit_code == 0\n+ assert \"b1\" in result.output\n+ assert \"hello\" in result.output\n+\n+\n+# ── Status command ─────────────────────────────────────────────────────\n+\n+\n+class TestStatusCommand:\n+ def test_status(self, runner, mock_ctx):\n+ \"\"\"status shows connection info.\"\"\"\n+ mock_ctx.client.status.return_value = {\n+ \"connected\": True,\n+ \"version\": \"3.6.5\",\n+ }\n+ mock_ctx.client.get_version.return_value = \"3.6.5\"\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ mock_session = MagicMock()\n+ mock_session.state.connected = True\n+ mock_session.state.current_notebook_id = \"nb1\"\n+ mock_session.state.current_notebook_name = \"工作\"\n+ mock_session.state.current_doc_id = \"doc1\"\n+ mock_ctx.client.get_version.return_value = \"3.6.5\"\n+ mock_ctx.session = mock_session\n+ mock_ctx.current_notebook_id = \"nb1\"\n+ mock_ctx.current_notebook_name = \"工作\"\n+ mock_ctx.current_doc_id = \"doc1\"\n+\n+ result = runner.invoke(cli, [\"status\"])\n+ assert result.exit_code == 0\n+ assert \"Connected\" in result.output or \"connected\" in result.output.lower()\n+\n+\n+# ── Block insert command ────────────────────────────────────────────────\n+\n+\n+class TestBlockInsertCommand:\n+ def test_block_insert_with_parent(self, runner, mock_ctx):\n+ \"\"\"block insert with --parent succeeds.\"\"\"\n+ mock_ctx.client.insert_block.return_value = [{\"id\": \"new-block\"}]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"block\", \"insert\", \"hello\", \"--parent\", \"pid\"])\n+ assert result.exit_code == 0\n+ assert \"Block inserted\" in result.output\n+ mock_ctx.client.insert_block.assert_called_once_with(\n+ \"markdown\", \"hello\", parent_id=\"pid\", previous_id=\"\", next_id=\"\"\n+ )\n+\n+ def test_block_insert_with_previous(self, runner, mock_ctx):\n+ \"\"\"block insert with --previous succeeds.\"\"\"\n+ mock_ctx.client.insert_block.return_value = [{\"id\": \"new-block\"}]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"block\", \"insert\", \"hello\", \"--previous\", \"prev\"])\n+ assert result.exit_code == 0\n+ assert \"Block inserted\" in result.output\n+ mock_ctx.client.insert_block.assert_called_once_with(\n+ \"markdown\", \"hello\", parent_id=\"\", previous_id=\"prev\", next_id=\"\"\n+ )\n+\n+ def test_block_insert_with_next(self, runner, mock_ctx):\n+ \"\"\"block insert with --next succeeds.\"\"\"\n+ mock_ctx.client.insert_block.return_value = [{\"id\": \"new-block\"}]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"block\", \"insert\", \"hello\", \"--next\", \"nid\"])\n+ assert result.exit_code == 0\n+ assert \"Block inserted\" in result.output\n+ mock_ctx.client.insert_block.assert_called_once_with(\n+ \"markdown\", \"hello\", parent_id=\"\", previous_id=\"\", next_id=\"nid\"\n+ )\n+\n+ def test_block_insert_without_anchor_errors(self, runner, mock_ctx):\n+ \"\"\"block insert without any anchor raises UsageError.\"\"\"\n+ mock_ctx.client.insert_block.return_value = [{\"id\": \"new-block\"}]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"block\", \"insert\", \"hello\"])\n+ assert result.exit_code == 2\n+ assert \"anchor\" in result.output.lower() or \"Error\" in result.output\n+\n+ def test_block_insert_json_output(self, runner, mock_ctx):\n+ \"\"\"--json block insert returns raw data.\"\"\"\n+ mock_ctx.json_output = True\n+ mock_ctx.client.insert_block.return_value = [{\"id\": \"new-block\"}]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"--json\", \"block\", \"insert\", \"hello\", \"--parent\", \"pid\"])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[0][\"id\"] == \"new-block\"\n+\n+\n+# ── Doc get command ────────────────────────────────────────────────────\n+\n+\n+class TestDocGetCommand:\n+ def test_doc_get(self, runner, mock_ctx):\n+ \"\"\"doc get shows document path.\"\"\"\n+ mock_ctx.client.get_hpath_by_id.return_value = \"/我的文档/测试\"\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"doc\", \"get\", \"doc123\"])\n+ assert result.exit_code == 0\n+ assert \"/我的文档/测试\" in result.output\n+\n+\n+# ── Doc create command ──────────────────────────────────────────────────\n+\n+\n+class TestDocCreateCommand:\n+ def test_doc_create_without_md(self, runner, mock_ctx):\n+ \"\"\"doc create without --md does not read stdin (passes empty string).\"\"\"\n+ mock_ctx.client.create_doc_with_md.return_value = \"doc123\"\n+ with (\n+ patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx),\n+ ):\n+ result = runner.invoke(cli, [\"doc\", \"create\", \"nb1\", \"/test\"])\n+ assert result.exit_code == 0\n+ assert \"doc123\" in result.output\n+\n+ def test_doc_create_with_md(self, runner, mock_ctx):\n+ \"\"\"doc create with --md passes the markdown content.\"\"\"\n+ mock_ctx.client.create_doc_with_md.return_value = \"doc123\"\n+ with (\n+ patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx),\n+ ):\n+ result = runner.invoke(cli, [\"doc\", \"create\", \"nb1\", \"/test\", \"--md\", \"# Hello\"])\n+ assert result.exit_code == 0\n+ mock_ctx.client.create_doc_with_md.assert_called_with(\"nb1\", \"/test\", \"# Hello\")\n+ assert \"doc123\" in result.output\n+\n+ def test_doc_create_json_output(self, runner, mock_ctx):\n+ \"\"\"--json doc create returns doc ID.\"\"\"\n+ mock_ctx.json_output = True\n+ mock_ctx.client.create_doc_with_md.return_value = \"doc123\"\n+ with (\n+ patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx),\n+ ):\n+ result = runner.invoke(cli, [\"--json\", \"doc\", \"create\", \"nb1\", \"/test\"])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[\"id\"] == \"doc123\"\n+\n+\n+# ── Doc tree recursive rendering ──────────────────────────────────────\n+\n+\n+class TestDocTreeRecursiveCommand:\n+ def test_doc_tree_handle_nested_children(self, runner, mock_ctx):\n+ \"\"\"doc tree recursively renders nested children.\"\"\"\n+ mock_ctx.client.list_doc_tree.return_value = {\n+ \"files\": [\n+ {\n+ \"id\": \"doc1\", \"name\": \"Root\", \"depth\": 0,\n+ \"children\": [\n+ {\"id\": \"doc2\", \"name\": \"Child\", \"depth\": 1, \"children\": []},\n+ ],\n+ },\n+ {\"id\": \"doc3\", \"name\": \"Sibling\", \"depth\": 0, \"children\": []},\n+ ],\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"doc\", \"tree\", \"nb1\"])\n+ assert result.exit_code == 0\n+ assert \"Root\" in result.output\n+ assert \"Child\" in result.output\n+ assert \"Sibling\" in result.output\n+ assert \"doc1\" in result.output\n+ assert \"doc2\" in result.output\n+\n+ def test_doc_tree_flat_items(self, runner, mock_ctx):\n+ \"\"\"doc tree also works with flat items (no children key).\"\"\"\n+ mock_ctx.client.list_doc_tree.return_value = [\n+ {\"id\": \"doc1\", \"name\": \"Flat1\", \"depth\": 0},\n+ {\"id\": \"doc2\", \"name\": \"Flat2\", \"depth\": 1},\n+ ]\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"doc\", \"tree\", \"nb1\"])\n+ assert result.exit_code == 0\n+ assert \"Flat1\" in result.output\n+ assert \"Flat2\" in result.output\n+\n+ def test_doc_tree_nested_json_output(self, runner, mock_ctx):\n+ \"\"\"--json doc tree with nested children returns raw data.\"\"\"\n+ mock_ctx.json_output = True\n+ mock_ctx.client.list_doc_tree.return_value = {\n+ \"files\": [{\"id\": \"doc1\", \"name\": \"Root\", \"children\": []}],\n+ }\n+ with patch(\"cli_anything.siyuan.siyuan_cli.SiYuanContext\", return_value=mock_ctx):\n+ result = runner.invoke(cli, [\"--json\", \"doc\", \"tree\", \"nb1\"])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[0][\"id\"] == \"doc1\"\ndiff --git a/siyuan/agent-harness/cli_anything/siyuan/tests/test_core.py b/siyuan/agent-harness/cli_anything/siyuan/tests/test_core.py\nnew file mode 100644\nindex 000000000..4f81c107d\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/tests/test_core.py\n@@ -0,0 +1,204 @@\n+\"\"\"Unit tests for cli-anything-siyuan core modules.\n+\n+Tests use synthetic data and mocking — no external dependencies.\n+\"\"\"\n+\n+import json\n+import os\n+import tempfile\n+from pathlib import Path\n+from unittest.mock import MagicMock, patch\n+\n+import pytest\n+\n+from cli_anything.siyuan.core.client import SiYuanClient, SiYuanConfig, load_config\n+from cli_anything.siyuan.core.session import SessionManager, SessionState\n+\n+\n+# ── Client config tests ────────────────────────────────────────────────\n+\n+class TestClientConfig:\n+ def test_default_config(self):\n+ \"\"\"Default config has correct default values.\"\"\"\n+ config = SiYuanConfig()\n+ assert config.host == \"127.0.0.1\"\n+ assert config.port == 6806\n+ assert config.token == \"\"\n+ assert config.base_url == \"http://127.0.0.1:6806\"\n+\n+ def test_custom_config(self):\n+ \"\"\"Custom config values are used.\"\"\"\n+ config = SiYuanConfig(host=\"localhost\", port=6807, token=\"abc123\")\n+ assert config.host == \"localhost\"\n+ assert config.port == 6807\n+ assert config.token == \"abc123\"\n+ assert config.base_url == \"http://localhost:6807\"\n+\n+ @patch.dict(os.environ, {\"SIYUAN_HOST\": \"192.168.1.100\", \"SIYUAN_PORT\": \"6808\", \"SIYUAN_TOKEN\": \"envtoken\"}, clear=True)\n+ @patch(\"cli_anything.siyuan.core.client.Path.home\")\n+ def test_load_config_from_env(self, mock_home):\n+ \"\"\"load_config reads from environment variables.\"\"\"\n+ mock_home.return_value = Path(tempfile.mkdtemp())\n+ config = load_config()\n+ assert config.host == \"192.168.1.100\"\n+ assert config.port == 6808\n+ assert config.token == \"envtoken\"\n+\n+ def test_load_config_from_file(self):\n+ \"\"\"load_config reads from JSON config file.\"\"\"\n+ with tempfile.NamedTemporaryFile(mode=\"w\", suffix=\".json\", delete=False, encoding=\"utf-8\") as f:\n+ json.dump({\"host\": \"10.0.0.1\", \"port\": 6809, \"token\": \"filetoken\"}, f)\n+ fname = f.name\n+ try:\n+ config = load_config(fname)\n+ assert config.host == \"10.0.0.1\"\n+ assert config.port == 6809\n+ assert config.token == \"filetoken\"\n+ finally:\n+ os.unlink(fname)\n+\n+\n+# ── Client API tests ───────────────────────────────────────────────────\n+\n+class TestSiYuanClient:\n+ @pytest.fixture\n+ def client(self):\n+ return SiYuanClient(SiYuanConfig(token=\"test-token\"))\n+\n+ def test_ping_success(self, client):\n+ \"\"\"ping returns True when server responds.\"\"\"\n+ mock_session = MagicMock()\n+ mock_session.post.return_value.status_code = 200\n+ mock_session.post.return_value.json.return_value = {\"code\": 0, \"data\": \"3.6.5\"}\n+ client._session = mock_session\n+ assert client.ping() is True\n+\n+ def test_ping_failure(self, client):\n+ \"\"\"ping returns False when server is unreachable.\"\"\"\n+ mock_session = MagicMock()\n+ mock_session.post.side_effect = __import__(\"requests\").ConnectionError(\"refused\")\n+ client._session = mock_session\n+ assert client.ping() is False\n+\n+ def test_list_notebooks(self, client):\n+ \"\"\"list_notebooks parses API response correctly.\"\"\"\n+ mock_data = {\n+ \"notebooks\": [\n+ {\"id\": \"nb1\", \"name\": \"Test Notebook\", \"icon\": \"1f4d4\", \"closed\": False},\n+ {\"id\": \"nb2\", \"name\": \"Daily Notes\", \"icon\": \"1f4cb\", \"closed\": True},\n+ ]\n+ }\n+ mock_session = MagicMock()\n+ mock_session.post.return_value.status_code = 200\n+ mock_session.post.return_value.json.return_value = {\"code\": 0, \"data\": mock_data}\n+ client._session = mock_session\n+\n+ notebooks = client.list_notebooks()\n+ assert len(notebooks) == 2\n+ assert notebooks[0][\"name\"] == \"Test Notebook\"\n+ assert notebooks[1][\"id\"] == \"nb2\"\n+\n+ def test_create_doc_with_md(self, client):\n+ \"\"\"create_doc_with_md returns the doc ID.\"\"\"\n+ mock_session = MagicMock()\n+ mock_session.post.return_value.status_code = 200\n+ mock_session.post.return_value.json.return_value = {\"code\": 0, \"data\": \"doc123\"}\n+ client._session = mock_session\n+\n+ doc_id = client.create_doc_with_md(\"nb1\", \"/test/path\", \"# Hello\")\n+ assert doc_id == \"doc123\"\n+ # Verify correct API call (requests uses json= kwarg, not data=)\n+ call_kwargs = mock_session.post.call_args[1]\n+ body = call_kwargs[\"json\"]\n+ assert body[\"notebook\"] == \"nb1\"\n+ assert body[\"path\"] == \"/test/path\"\n+ assert body[\"markdown\"] == \"# Hello\"\n+\n+ def test_query_sql(self, client):\n+ \"\"\"query_sql returns list of rows.\"\"\"\n+ mock_session = MagicMock()\n+ mock_session.post.return_value.status_code = 200\n+ mock_session.post.return_value.json.return_value = {\n+ \"code\": 0, \"data\": [{\"id\": \"b1\", \"content\": \"hello\"}, {\"id\": \"b2\", \"content\": \"world\"}],\n+ }\n+ client._session = mock_session\n+\n+ results = client.query_sql(\"SELECT * FROM blocks\")\n+ assert len(results) == 2\n+ assert results[0][\"content\"] == \"hello\"\n+\n+\n+# ── Session tests ──────────────────────────────────────────────────────\n+\n+class TestSessionManager:\n+ @pytest.fixture\n+ def mgr(self):\n+ tmp_dir = tempfile.mkdtemp()\n+ return SessionManager(state_dir=tmp_dir)\n+\n+ def test_default_state(self, mgr):\n+ \"\"\"Fresh session has correct defaults.\"\"\"\n+ assert mgr.state.connected is False\n+ assert mgr.state.current_notebook_id == \"\"\n+ assert mgr.state.current_notebook_name == \"\"\n+ assert mgr.state.current_doc_id == \"\"\n+\n+ def test_save_load_roundtrip(self, mgr):\n+ \"\"\"Save then load preserves all state.\"\"\"\n+ mgr.update(current_notebook_id=\"nb1\", current_notebook_name=\"Test\", connected=True)\n+ mgr.save()\n+\n+ mgr2 = SessionManager(state_dir=str(mgr.state_dir))\n+ mgr2.load()\n+ assert mgr2.state.current_notebook_id == \"nb1\"\n+ assert mgr2.state.current_notebook_name == \"Test\"\n+ assert mgr2.state.connected is True\n+\n+ def test_partial_update(self, mgr):\n+ \"\"\"Update only changes specified fields.\"\"\"\n+ mgr.update(current_notebook_id=\"nb1\")\n+ assert mgr.state.current_notebook_id == \"nb1\"\n+ assert mgr.state.connected is False # unchanged\n+\n+\n+class TestFindReplace:\n+ \"\"\"Tests for find_replace using SiYuan API k/r/ids payload.\"\"\"\n+\n+ @pytest.fixture\n+ def client(self):\n+ return SiYuanClient(SiYuanConfig(token=\"test-token\"))\n+\n+ def test_find_replace_uses_k_r_ids_payload(self, client):\n+ \"\"\"find_replace sends k/r/ids payload keys.\"\"\"\n+ mock_session = MagicMock()\n+ mock_session.post.return_value.status_code = 200\n+ mock_session.post.return_value.json.return_value = {\"code\": 0, \"data\": {\"count\": 3}}\n+ client._session = mock_session\n+ client.find_replace(\"old\", \"new\", [\"id1\", \"id2\"])\n+ call_kwargs = mock_session.post.call_args[1]\n+ body = call_kwargs[\"json\"]\n+ assert \"k\" in body\n+ assert \"r\" in body\n+ assert \"ids\" in body\n+ assert body[\"k\"] == \"old\"\n+ assert body[\"r\"] == \"new\"\n+ assert body[\"ids\"] == [\"id1\", \"id2\"]\n+\n+class TestUncappedListings:\n+ \"\"\"Tests for list_docs_by_path with maxListCount.\"\"\"\n+\n+ @pytest.fixture\n+ def client(self):\n+ return SiYuanClient(SiYuanConfig(token=\"test-token\"))\n+\n+ def test_list_docs_by_path_sends_max_list_count(self, client):\n+ \"\"\"list_docs_by_path sends maxListCount: 0 for uncapped listings.\"\"\"\n+ mock_session = MagicMock()\n+ mock_session.post.return_value.status_code = 200\n+ mock_session.post.return_value.json.return_value = {\"code\": 0, \"data\": {\"files\": [{\"id\": \"doc1\", \"name\": \"test\"}]}}\n+ client._session = mock_session\n+ client.list_docs_by_path(\"nb1\", \"/\")\n+ call_kwargs = mock_session.post.call_args[1]\n+ body = call_kwargs[\"json\"]\n+ assert \"maxListCount\" in body\n+ assert body[\"maxListCount\"] == 0\ndiff --git a/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py b/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2efee700a\n--- /dev/null\n+++ b/siyuan/agent-harness/cli_anything/siyuan/tests/test_full_e2e.py\n@@ -0,0 +1,122 @@\n+\"\"\"E2E tests for cli-anything-siyuan.\n+\n+Requires a running SiYuan instance at http://127.0.0.1:6806.\n+Set SIYUAN_TOKEN env var if authentication is enabled.\n+\"\"\"\n+\n+import json\n+import os\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.siyuan.core.client import SiYuanClient, SiYuanClientError, load_config\n+\n+\n+def _resolve_cli(name: str) -> list[str]:\n+ \"\"\"Resolve installed CLI command; falls back to python -m for dev.\"\"\"\n+ import shutil\n+ force = os.environ.get(\"CLI_ANYTHING_FORCE_INSTALLED\", \"\").strip() == \"1\"\n+ path = shutil.which(name)\n+ if path:\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+ if force:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ module = name.replace(\"cli-anything-\", \"cli_anything.\") # e.g. cli_anything.siyuan (has __main__.py)\n+ print(f\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+\n+CLI_BASE = _resolve_cli(\"cli-anything-siyuan\")\n+\n+\n+# ── Fixtures ───────────────────────────────────────────────────────────\n+\n+@pytest.fixture(scope=\"session\")\n+def client() -> SiYuanClient:\n+ \"\"\"Create a client connected to the real SiYuan instance.\"\"\"\n+ config = load_config()\n+ c = SiYuanClient(config)\n+ if not c.ping():\n+ pytest.skip(\"SiYuan is not running — E2E tests require a running instance\")\n+ return c\n+\n+\n+@pytest.fixture\n+def tmp_dir() -> Path:\n+ \"\"\"Create a temporary directory for test artifacts.\"\"\"\n+ import tempfile\n+ path = Path(tempfile.mkdtemp(prefix=\"siyuan_e2e_\"))\n+ yield path\n+ import shutil\n+ shutil.rmtree(path, ignore_errors=True)\n+\n+\n+class TestCLISubprocess:\n+ CLI_BASE = CLI_BASE\n+\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess:\n+ return subprocess.run(\n+ self.CLI_BASE + args,\n+ capture_output=True, text=True, check=check,\n+ )\n+\n+ def test_help(self):\n+ \"\"\"--help returns 0 and shows usage.\"\"\"\n+ result = self._run([\"--help\"])\n+ assert result.returncode == 0\n+ assert \"Usage:\" in result.stdout\n+ print(f\"\\n --help: OK ({len(result.stdout)} chars)\")\n+\n+ def test_version_json(self, client: SiYuanClient):\n+ \"\"\"--json version returns valid JSON with version string.\"\"\"\n+ result = self._run([\"--json\", \"version\"])\n+ assert result.returncode == 0\n+ data = json.loads(result.stdout)\n+ assert \"version\" in data\n+ assert data[\"version\"]\n+ print(f\"\\n SiYuan version: {data['version']}\")\n+\n+ def test_status_json(self, client: SiYuanClient):\n+ \"\"\"--json status returns valid JSON with connection info.\"\"\"\n+ result = self._run([\"--json\", \"status\"])\n+ assert result.returncode == 0\n+ data = json.loads(result.stdout)\n+ assert \"siyuan_version\" in data\n+ assert data[\"siyuan_version\"]\n+ print(f\"\\n Status: connected to SiYuan v{data['siyuan_version']}\")\n+\n+\n+class TestBackendE2E:\n+ \"\"\"Tests that hit the real SiYuan API via Python client.\"\"\"\n+\n+ def test_get_version(self, client: SiYuanClient):\n+ \"\"\"Get the SiYuan kernel version from a running instance.\"\"\"\n+ ver = client.get_version()\n+ assert ver\n+ assert isinstance(ver, str)\n+ assert len(ver) > 0\n+ print(f\"\\n SiYuan kernel version: {ver}\")\n+\n+ def test_list_notebooks(self, client: SiYuanClient):\n+ \"\"\"List all notebooks from the running instance.\"\"\"\n+ notebooks = client.list_notebooks()\n+ assert isinstance(notebooks, list)\n+ if notebooks:\n+ nb = notebooks[0]\n+ assert \"id\" in nb\n+ assert \"name\" in nb\n+ print(f\"\\n Notebooks found: {len(notebooks)}\")\n+ print(f\" First: {nb['name']} ({nb['id']})\")\n+ else:\n+ print(\"\\n No notebooks found (empty instance)\")\n+\n+ def test_get_current_time(self, client: SiYuanClient):\n+ \"\"\"Get current time from server.\"\"\"\n+ t = client.get_current_time()\n+ assert t > 0\n+ assert isinstance(t, int)\n+ print(f\"\\n Server time (ts): {t}\")\n"},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4828,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":344,"string":"344"},"task_type":{"kind":"string","value":"issue_to_patch"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"feat: add Reasonix agent skill adapter"},"pr_body":{"kind":"string","value":"## Summary / 概述\n\n**English:** Add a Reasonix agent adapter that lets users build, refine, test, and validate CLI-Anything harnesses from Reasonix sessions.\n\n**中文：** 为 Reasonix 编程智能体添加 CLI-Anything 适配器，使用户可以在 Reasonix 会话中构建、优化、测试和验证 CLI-Anything harness。\n\nReasonix project: https://github.com/esengine/DeepSeek-Reasonix\n\n## What this PR adds\n\n- `reasonix-skill/SKILL.md`: maps the CLI-Anything workflow to Reasonix tools and runs as an isolated subagent.\n- `reasonix-skill/scripts/install.sh`: installs the skill to `~/.reasonix/skills/cli-anything` on macOS/Linux.\n- `reasonix-skill/scripts/install.ps1`: installs the skill to the same global skill directory on Windows.\n- `reasonix-skill/README.md`: documents installation, usage, and tool mapping.\n- `reasonix-skill/agents/reasonix.yaml`: agent interface metadata.\n- Root documentation and allowlist updates for the new adapter.\n\nThe adapter uses Reasonix's `bash`, file editing, search, and web tools. CodeGraph tools are used only when CodeGraph is enabled and available. Because the skill runs with `runAs: subagent`, it does not claim access to the parent-only `task` orchestration tool.\n\nThe skill also preserves the current CLI-Anything packaging requirements by generating both the canonical `skills/cli-anything-<software>/SKILL.md` and the package-local `cli_anything/<software>/skills/SKILL.md`.\n\n## Installation / 安装\n\n```bash\ngit clone https://github.com/HKUDS/CLI-Anything.git\nbash CLI-Anything/reasonix-skill/scripts/install.sh\n```\n\nWindows PowerShell:\n\n```powershell\n.\\CLI-Anything\\reasonix-skill\\scripts\\install.ps1\n```\n\nThe scripts install to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`. Restart Reasonix after installation so the skill is discovered.\n\n## Usage / 使用\n\n```text\n/cli-anything https://github.com/GNOME/gimp\n/cli-anything /path/to/software \"Refine the existing harness for batch processing\"\n```\n\n## Verification\n\n- `git diff --check`\n- `bash -n reasonix-skill/scripts/install.sh`\n- Isolated temporary-home installation and duplicate-install protection\n- `python3 .github/scripts/validate_root_skills.py`\n- `node .github/scripts/tests/pr-labeler.test.js`\n- Static scan confirming the Reasonix adapter no longer documents unsupported `REASONIX_HOME`, `install_skill`, `task`, or `/cli-anything:refine` behavior\n\nPowerShell execution was not available in the local verification environment; the PowerShell installer was reviewed statically."},"base_sha":{"kind":"string","value":"f23e051a053dfe34737f3d542f9fb3952d23922d"},"head_sha":{"kind":"string","value":"d1eedc958e829593f6578739c6d0d4855913a523"},"gold_diff":{"kind":"string","value":"diff --git a/.gitignore b/.gitignore\nindex 618c70154..8a4fae99c 100644\n--- a/.gitignore\n+++ b/.gitignore\n@@ -34,6 +34,7 @@\n !/cli-anything-plugin/\n !/codex-skill/\n !/hermes-skill/\n+!/reasonix-skill/\n !/skill_generation/\n !/openclaw-skill/\n !/cli-hub-meta-skill/\ndiff --git a/README.md b/README.md\nindex 9672f4ab2..1e255560f 100644\n--- a/README.md\n+++ b/README.md\n@@ -236,7 +236,7 @@ Give SKILL-compatible agents the CLI-Hub meta-skill so they can discover and ins\n npx skills add HKUDS/CLI-Anything --skill cli-hub-meta-skill -g -y\n ```\n \n-**Works with:** OpenClaw, Nanobot, Claude Code, Codex, Antigravity, and other SKILL-compatible agents.\n+**Works with:** OpenClaw, Nanobot, Claude Code, Codex, Reasonix, Antigravity, and other SKILL-compatible agents.\n \n Then prompt:\n \n@@ -255,7 +255,7 @@ Use the CLI-Anything generator when you need a new harness for software, a codeb\n \n - **Python 3.10+**\n - Target software or source repo available locally or online\n-- A supported AI coding agent: [Claude Code](#-claude-code) | [Pi](#-pi-coding-agent) | [OpenClaw](#-openclaw) | [OpenCode](#-opencode) | [Codex](#-codex) | [Hermes](#-hermes) | [Qodercli](#-qodercli) | [GitHub Copilot CLI](#-github-copilot-cli) | [More Platforms](#-more-platforms-coming-soon)\n+- A supported AI coding agent: [Claude Code](#-claude-code) | [Pi](#-pi-coding-agent) | [OpenClaw](#-openclaw) | [OpenCode](#-opencode) | [Codex](#-codex) | [Hermes](#-hermes) | [Reasonix](#-reasonix) | [Qodercli](#-qodercli) | [GitHub Copilot CLI](#-github-copilot-cli) | [More Platforms](#-more-platforms-coming-soon)\n \n ### Pick Your Agent Platform\n \n@@ -615,6 +615,48 @@ keeping the generated Python harness format unchanged.\n \n <details>\n \n+<summary><h4 id=\"-reasonix\">⚡ Reasonix <sup><code>Experimental</code></sup> <sup><code>Community</code></sup></h4></summary>\n+\n+**Step 1: Install the Skill**\n+\n+Run the bundled installer:\n+\n+```bash\n+# Clone the repo\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+\n+# Install the skill\n+bash CLI-Anything/reasonix-skill/scripts/install.sh\n+```\n+\n+On Windows PowerShell, use:\n+\n+```powershell\n+.\\CLI-Anything\\reasonix-skill\\scripts\\install.ps1\n+```\n+\n+This installs the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\n+\n+Restart Reasonix after installation so it is discovered.\n+\n+**Step 2: Use CLI-Anything from Reasonix**\n+\n+Describe the task in natural language, for example:\n+\n+```text\n+Use CLI-Anything to build a harness for ./gimp\n+Use CLI-Anything to refine ./shotcut for picture-in-picture workflows\n+Use CLI-Anything to validate ./libreoffice\n+```\n+\n+The Reasonix skill adapts the same methodology used by the Claude Code plugin and\n+Codex/Hermes skills, binding Reasonix's `bash`, `write_file`, `edit_file`,\n+`multi_edit`, `grep`, `glob`, and optional `mcp__codegraph__search` / `mcp__codegraph__context` tools to the\n+7-phase harness workflow while keeping the generated Python harness format unchanged.\n+</details>\n+\n+<details>\n+\n <summary><h4 id=\"-github-copilot-cli\">⚡ GitHub Copilot CLI <sup><code>Community</code></sup></h4></summary>\n \n **Step 1: Install the Plugin**\n@@ -1340,6 +1382,7 @@ cli-anything/\n │\n ├── 🤖 codex-skill/ # Codex skill entry point\n ├── 🧭 hermes-skill/ # Hermes Agent skill entry point\n+├── 🧠 reasonix-skill/ # Reasonix skill entry point\n ├── 🎨 gimp/agent-harness/ # GIMP CLI (107 tests)\n ├── 🧊 blender/agent-harness/ # Blender CLI (208 tests)\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI (202 tests)\ndiff --git a/reasonix-skill/README.md b/reasonix-skill/README.md\nnew file mode 100644\nindex 000000000..6233720ff\n--- /dev/null\n+++ b/reasonix-skill/README.md\n@@ -0,0 +1,116 @@\n+# CLI-Anything for Reasonix\n+\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\n+\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\n+\n+## Installation\n+\n+**macOS / Linux:**\n+\n+```bash\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything/reasonix-skill\n+./scripts/install.sh\n+```\n+\n+**Windows (PowerShell):**\n+\n+```powershell\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything\\reasonix-skill\n+.\\scripts\\install.ps1\n+```\n+\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\n+\n+## Configuration Note\n+\n+A full CLI-Anything build (architecture analysis, 10+ file generation, installation, and multiple test runs) typically requires 25–40 tool-call rounds. Reasonix's subagent step budget is derived from the `agent.max_steps` setting in `reasonix.toml`:\n+\n+- The default `max_steps = 0` means unlimited, which is recommended for this workflow.\n+- If you have set `max_steps` to a finite value, the subagent receives half that budget (minimum 5), which may cause a build to be truncated before completion.\n+\n+To ensure builds complete successfully, set `agent.max_steps = 0` in your `reasonix.toml`, or use a sufficiently high value such as 64 or more.\n+\n+## Usage\n+\n+After installation, use slash invocation to inline the skill into the parent Reasonix loop:\n+\n+```\n+/cli-anything https://github.com/GNOME/gimp\n+```\n+\n+Use `run_skill` when you want isolated subagent execution. The same isolation applies when Reasonix invokes the skill through its dedicated subagent path:\n+\n+```\n+run_skill({ name: \"cli-anything\", arguments: \"/path/to/software\" })\n+```\n+\n+### What It Does\n+\n+The skill follows the CLI-Anything 7-phase methodology:\n+\n+1. **Codebase Analysis** — Surveys the target software's architecture, data model, and API surface\n+2. **CLI Architecture Design** — Designs command groups, state model, and output formats\n+3. **Implementation** — Generates a Click-based Python CLI with REPL, JSON output, and session state\n+4. **Test Planning** — Creates TEST.md with comprehensive test plan\n+5. **Test Implementation** — Writes unit tests and E2E tests with real backend invocation\n+6. **Test Documentation** — Runs all tests and documents results\n+7. **PyPI Packaging** — Creates setup.py and verifies `pip install -e .`\n+\n+### Example\n+\n+```bash\n+# Build a CLI for GIMP from local source\n+/cli-anything /home/user/gimp\n+\n+# Build from a GitHub repo\n+/cli-anything https://github.com/blender/blender\n+\n+# Refine an existing harness\n+/cli-anything /home/user/gimp \"Refine the existing harness for batch processing and Script-Fu filters\"\n+```\n+\n+## Reasonix Tool Mapping\n+\n+| CLI-Anything Need | Reasonix Tool |\n+|-------------------|---------------|\n+| Shell execution | `bash` |\n+| File generation | `write_file` |\n+| Code editing | `edit_file` / `multi_edit` |\n+| Source reading | `read_file` |\n+| Codebase search | `grep` / `glob` / `ls` |\n+| Architecture analysis | `mcp__codegraph__search` / `mcp__codegraph__context` when CodeGraph is enabled |\n+| Documentation fetch | `web_fetch` |\n+\n+## File Structure\n+\n+```\n+reasonix-skill/\n+├── SKILL.md # Main skill document (methodology + tool bindings)\n+├── README.md # This file\n+├── agents/\n+│ └── reasonix.yaml # Agent interface metadata\n+└── scripts/\n+ ├── install.sh # macOS/Linux installer\n+ └── install.ps1 # Windows installer\n+```\n+\n+## How It Compares to Other Agent Adapters\n+\n+| Feature | Claude Code | Codex | Hermes | **Reasonix** |\n+|---------|------------|-------|--------|-------------|\n+| Skill format | `.claude-plugin/` | `SKILL.md` + YAML | `SKILL.md` + YAML | `SKILL.md` + YAML |\n+| Shell | `bash` | `terminal` | `terminal` | `bash` |\n+| File ops | native | `execute_code` | `execute_code` / `write_file` | `write_file` / `edit_file` / `multi_edit` |\n+| Code analysis | file reads | file reads | file reads | Optional `mcp__codegraph__search` / `mcp__codegraph__context` symbol graph |\n+| Install method | `/plugin install` | `install.sh` → `$CODEX_HOME/skills/` | `install.sh` → `$HERMES_HOME/skills/` | `install.sh` → `~/.reasonix/skills/` |\n+\n+## Contributing\n+\n+This adapter follows the same contribution pattern as the Codex and Hermes adapters. See [CONTRIBUTING.md](../CONTRIBUTING.md) in the CLI-Anything repository.\n+\n+## License\n+\n+Apache License 2.0 — same as CLI-Anything.\ndiff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\ndiff --git a/reasonix-skill/agents/reasonix.yaml b/reasonix-skill/agents/reasonix.yaml\nnew file mode 100644\nindex 000000000..2694768f1\n--- /dev/null\n+++ b/reasonix-skill/agents/reasonix.yaml\n@@ -0,0 +1,4 @@\n+interface:\n+ display_name: \"CLI-Anything\"\n+ short_description: \"Build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository from Reasonix.\"\n+ default_prompt: \"Use CLI-Anything to build, refine, test, or validate a harness for the user's target software or source repository.\"\ndiff --git a/reasonix-skill/scripts/install.ps1 b/reasonix-skill/scripts/install.ps1\nnew file mode 100644\nindex 000000000..87f7f70e7\n--- /dev/null\n+++ b/reasonix-skill/scripts/install.ps1\n@@ -0,0 +1,24 @@\n+$ErrorActionPreference = \"Stop\"\n+\n+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path\n+$skillDir = Split-Path -Parent $scriptDir\n+\n+$reasonixHome = if ($env:USERPROFILE) {\n+ Join-Path $env:USERPROFILE \".reasonix\"\n+} else {\n+ throw \"USERPROFILE is unavailable.\"\n+}\n+\n+$destRoot = Join-Path $reasonixHome \"skills\"\n+$destDir = Join-Path $destRoot \"cli-anything\"\n+\n+New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\n+\n+if (Test-Path $destDir) {\n+ Write-Error \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n+}\n+\n+Copy-Item -Path $skillDir -Destination $destDir -Recurse\n+\n+Write-Host \"Installed Reasonix skill to: $destDir\"\n+Write-Host \"Restart Reasonix to pick up the new skill.\"\ndiff --git a/reasonix-skill/scripts/install.sh b/reasonix-skill/scripts/install.sh\nnew file mode 100755\nindex 000000000..49c538a65\n--- /dev/null\n+++ b/reasonix-skill/scripts/install.sh\n@@ -0,0 +1,22 @@\n+#!/usr/bin/env bash\n+\n+set -euo pipefail\n+\n+SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n+SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+: \"${HOME:?HOME must be set to install a global Reasonix skill}\"\n+DEST_ROOT=\"${HOME}/.reasonix/skills\"\n+DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+\n+mkdir -p \"${DEST_ROOT}\"\n+\n+if [[ -e \"${DEST_DIR}\" ]]; then\n+ echo \"Refusing to overwrite existing skill: ${DEST_DIR}\" >&2\n+ echo \"Remove it manually if you want to reinstall.\" >&2\n+ exit 1\n+fi\n+\n+cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+\n+echo \"Installed Reasonix skill to: ${DEST_DIR}\"\n+echo \"Restart Reasonix to pick up the new skill.\"\n"},"changed_files":{"kind":"list like","value":[".gitignore","README.md","reasonix-skill/README.md","reasonix-skill/SKILL.md","reasonix-skill/agents/reasonix.yaml","reasonix-skill/scripts/install.ps1","reasonix-skill/scripts/install.sh"],"string":"[\n \".gitignore\",\n \"README.md\",\n \"reasonix-skill/README.md\",\n \"reasonix-skill/SKILL.md\",\n \"reasonix-skill/agents/reasonix.yaml\",\n \"reasonix-skill/scripts/install.ps1\",\n \"reasonix-skill/scripts/install.sh\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"**<sub><sub></sub></sub> Declare the skill as a subagent in frontmatter**\n\nFor the shell/PowerShell install path, Reasonix loads this `SKILL.md` directly from `~/.reasonix/skills/cli-anything/SKILL.md`; Reasonix's skill docs say `runAs` defaults to `inline` and only `runAs: subagent` runs the body in an isolated child loop. Because the adapter documentation and README promise this skill spawns an isolated sub-agent, users who install via the bundled scripts will instead run the whole CLI-Anything workflow inline in their parent session unless the frontmatter includes `runAs: subagent`.\n\nUseful? React with 👍 / 👎.","path":"reasonix-skill/SKILL.md","hunk":"@@ -0,0 +1,146 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+---","resolving_sha":"d1eedc958e829593f6578739c6d0d4855913a523","resolving_diff":"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\n"},{"comment":"**<sub><sub></sub></sub> Use Reasonix's registered shell and search tool names**\n\nThe adapter instructs its isolated subagent to call `bash` throughout implementation, testing, and packaging, but current Reasonix registers the shell tool as `run_command`; its corresponding search/list tools are `search_content` and `list_directory`, not `grep` and `ls`. Because a `runAs: subagent` skill receives this body as its operating instructions, following the documented workflow produces nonexistent-tool calls before it can install or test a harness. Update the bindings and phase instructions to use Reasonix's actual registered tool names.\n\nUseful? React with 👍 / 👎.","path":"reasonix-skill/SKILL.md","hunk":"@@ -0,0 +1,155 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |","resolving_sha":"d1eedc958e829593f6578739c6d0d4855913a523","resolving_diff":"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\n"},{"comment":"**<sub><sub></sub></sub> Invoke the skill through Reasonix's skill command**\n\nReasonix exposes user skills through `/skill <name>` (or the `run_skill` tool), and does not dynamically register `/cli-anything` as a slash command. Consequently, users following this primary usage example receive an unknown-command result instead of invoking the installed skill; document the command as `/skill cli-anything ...` and update the examples below accordingly.\n\nUseful? React with 👍 / 👎.","path":"reasonix-skill/README.md","hunk":"@@ -0,0 +1,107 @@\n+# CLI-Anything for Reasonix\n+\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\n+\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\n+\n+## Installation\n+\n+**macOS / Linux:**\n+\n+```bash\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything/reasonix-skill\n+./scripts/install.sh\n+```\n+\n+**Windows (PowerShell):**\n+\n+```powershell\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything\\reasonix-skill\n+.\\scripts\\install.ps1\n+```\n+\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\n+\n+## Usage\n+\n+After installation, invoke the skill in any Reasonix session:\n+\n+```\n+/cli-anything https://github.com/GNOME/gimp","resolving_sha":"d1eedc958e829593f6578739c6d0d4855913a523","resolving_diff":"diff --git a/reasonix-skill/README.md b/reasonix-skill/README.md\nnew file mode 100644\nindex 000000000..6233720ff\n--- /dev/null\n+++ b/reasonix-skill/README.md\n@@ -0,0 +1,116 @@\n+# CLI-Anything for Reasonix\n+\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\n+\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\n+\n+## Installation\n+\n+**macOS / Linux:**\n+\n+```bash\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything/reasonix-skill\n+./scripts/install.sh\n+```\n+\n+**Windows (PowerShell):**\n+\n+```powershell\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything\\reasonix-skill\n+.\\scripts\\install.ps1\n+```\n+\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\n+\n+## Configuration Note\n+\n+A full CLI-Anything build (architecture analysis, 10+ file generation, installation, and multiple test runs) typically requires 25–40 tool-call rounds. Reasonix's subagent step budget is derived from the `agent.max_steps` setting in `reasonix.toml`:\n+\n+- The default `max_steps = 0` means unlimited, which is recommended for this workflow.\n+- If you have set `max_steps` to a finite value, the subagent receives half that budget (minimum 5), which may cause a build to be truncated before completion.\n+\n+To ensure builds complete successfully, set `agent.max_steps = 0` in your `reasonix.toml`, or use a sufficiently high value such as 64 or more.\n+\n+## Usage\n+\n+After installation, use slash invocation to inline the skill into the parent Reasonix loop:\n+\n+```\n+/cli-anything https://github.com/GNOME/gimp\n+```\n+\n+Use `run_skill` when you want isolated subagent execution. The same isolation applies when Reasonix invokes the skill through its dedicated subagent path:\n+\n+```\n+run_skill({ name: \"cli-anything\", arguments: \"/path/to/software\" })\n+```\n+\n+### What It Does\n+\n+The skill follows the CLI-Anything 7-phase methodology:\n+\n+1. **Codebase Analysis** — Surveys the target software's architecture, data model, and API surface\n+2. **CLI Architecture Design** — Designs command groups, state model, and output formats\n+3. **Implementation** — Generates a Click-based Python CLI with REPL, JSON output, and session state\n+4. **Test Planning** — Creates TEST.md with comprehensive test plan\n+5. **Test Implementation** — Writes unit tests and E2E tests with real backend invocation\n+6. **Test Documentation** — Runs all tests and documents results\n+7. **PyPI Packaging** — Creates setup.py and verifies `pip install -e .`\n+\n+### Example\n+\n+```bash\n+# Build a CLI for GIMP from local source\n+/cli-anything /home/user/gimp\n+\n+# Build from a GitHub repo\n+/cli-anything https://github.com/blender/blender\n+\n+# Refine an existing harness\n+/cli-anything /home/user/gimp \"Refine the existing harness for batch processing and Script-Fu filters\"\n+```\n+\n+## Reasonix Tool Mapping\n+\n+| CLI-Anything Need | Reasonix Tool |\n+|-------------------|---------------|\n+| Shell execution | `bash` |\n+| File generation | `write_file` |\n+| Code editing | `edit_file` / `multi_edit` |\n+| Source reading | `read_file` |\n+| Codebase search | `grep` / `glob` / `ls` |\n+| Architecture analysis | `mcp__codegraph__search` / `mcp__codegraph__context` when CodeGraph is enabled |\n+| Documentation fetch | `web_fetch` |\n+\n+## File Structure\n+\n+```\n+reasonix-skill/\n+├── SKILL.md # Main skill document (methodology + tool bindings)\n+├── README.md # This file\n+├── agents/\n+│ └── reasonix.yaml # Agent interface metadata\n+└── scripts/\n+ ├── install.sh # macOS/Linux installer\n+ └── install.ps1 # Windows installer\n+```\n+\n+## How It Compares to Other Agent Adapters\n+\n+| Feature | Claude Code | Codex | Hermes | **Reasonix** |\n+|---------|------------|-------|--------|-------------|\n+| Skill format | `.claude-plugin/` | `SKILL.md` + YAML | `SKILL.md` + YAML | `SKILL.md` + YAML |\n+| Shell | `bash` | `terminal` | `terminal` | `bash` |\n+| File ops | native | `execute_code` | `execute_code` / `write_file` | `write_file` / `edit_file` / `multi_edit` |\n+| Code analysis | file reads | file reads | file reads | Optional `mcp__codegraph__search` / `mcp__codegraph__context` symbol graph |\n+| Install method | `/plugin install` | `install.sh` → `$CODEX_HOME/skills/` | `install.sh` → `$HERMES_HOME/skills/` | `install.sh` → `~/.reasonix/skills/` |\n+\n+## Contributing\n+\n+This adapter follows the same contribution pattern as the Codex and Hermes adapters. See [CONTRIBUTING.md](../CONTRIBUTING.md) in the CLI-Anything repository.\n+\n+## License\n+\n+Apache License 2.0 — same as CLI-Anything.\n"},{"comment":"**<sub><sub></sub></sub> Raise the subagent iteration budget**\n\nWhen a build requires more than Reasonix's default 16 subagent iterations, the child loop stops before completing the harness; this workflow routinely needs architecture inspection, generation of 10+ files, installation, and multiple test runs. Reasonix documents `max-iters` as defaulting to 16 and allowing up to 32, so declare an appropriate `max-iters` value alongside `runAs: subagent` to avoid truncating the adapter's primary build workflow.\n\nUseful? React with 👍 / 👎.","path":"reasonix-skill/SKILL.md","hunk":"@@ -0,0 +1,155 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent","resolving_sha":"d1eedc958e829593f6578739c6d0d4855913a523","resolving_diff":"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\n"}],"string":"[\n {\n \"comment\": \"**<sub><sub></sub></sub> Declare the skill as a subagent in frontmatter**\\n\\nFor the shell/PowerShell install path, Reasonix loads this `SKILL.md` directly from `~/.reasonix/skills/cli-anything/SKILL.md`; Reasonix's skill docs say `runAs` defaults to `inline` and only `runAs: subagent` runs the body in an isolated child loop. Because the adapter documentation and README promise this skill spawns an isolated sub-agent, users who install via the bundled scripts will instead run the whole CLI-Anything workflow inline in their parent session unless the frontmatter includes `runAs: subagent`.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"reasonix-skill/SKILL.md\",\n \"hunk\": \"@@ -0,0 +1,146 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+---\",\n \"resolving_sha\": \"d1eedc958e829593f6578739c6d0d4855913a523\",\n \"resolving_diff\": \"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\\nnew file mode 100644\\nindex 000000000..f24056e91\\n--- /dev/null\\n+++ b/reasonix-skill/SKILL.md\\n@@ -0,0 +1,164 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\\n+---\\n+\\n+# CLI-Anything for Reasonix\\n+\\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\\n+\\n+Before implementation, use the full methodology source of truth when available:\\n+\\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\\n+\\n+## Inputs\\n+\\n+Accept either:\\n+\\n+- A local source path such as `./gimp` or `/path/to/software`\\n+- A GitHub repository URL\\n+\\n+Derive the software name from the local directory name after cloning if needed.\\n+\\n+## Reasonix Tool Bindings\\n+\\n+Reasonix agents build harnesses by combining these built-in tools:\\n+\\n+| Reasonix Tool | Role in Harness Workflow |\\n+|---------------|--------------------------|\\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\\n+| `read_file` | Read target software source files, existing harness code, test results |\\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\\n+| `ls` | List directory contents to understand project structure |\\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\\n+\\n+### Recommended Workflow with Reasonix Tools\\n+\\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\\n+\\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\\n+\\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\\n+\\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\\n+\\n+## Step Budget\\n+\\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\\n+\\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\\n+\\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\\n+\\n+## Modes\\n+\\n+### Build\\n+\\n+Use when the user wants a new harness.\\n+\\n+Produce this structure:\\n+\\n+```text\\n+<repo-root>/\\n+├── skills/\\n+│ └── cli-anything-<software>/\\n+│ └── SKILL.md\\n+└── <software>/\\n+ └── agent-harness/\\n+ ├── <SOFTWARE>.md\\n+ ├── setup.py\\n+ └── cli_anything/\\n+ └── <software>/\\n+ ├── README.md\\n+ ├── __init__.py\\n+ ├── __main__.py\\n+ ├── <software>_cli.py\\n+ ├── core/\\n+ ├── utils/\\n+ ├── tests/\\n+ └── skills/\\n+ └── SKILL.md\\n+```\\n+\\n+Implement a stateful Click CLI with:\\n+\\n+- one-shot subcommands\\n+- REPL mode as the default when no subcommand is given\\n+- `--json` machine-readable output\\n+- session state with undo/redo where the target software supports it\\n+\\n+### Refine\\n+\\n+Use when the harness already exists.\\n+\\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\\n+\\n+- high-impact missing features\\n+- easy wrappers around existing backend APIs or CLIs\\n+- additions that compose well with existing commands\\n+\\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\\n+\\n+### Test\\n+\\n+Plan tests before writing them. Keep both:\\n+\\n+- `test_core.py` for unit coverage\\n+- `test_full_e2e.py` for workflow and backend validation\\n+\\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\\n+\\n+### Validate\\n+\\n+Check that the harness:\\n+\\n+- uses the `cli_anything.<software>` namespace package layout\\n+- has an installable `setup.py` entry point\\n+- supports JSON output\\n+- has a REPL default path\\n+- has matching canonical and package-local `SKILL.md` files\\n+- documents usage and tests\\n+\\n+## Backend Rules\\n+\\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\\n+\\n+## Packaging Rules\\n+\\n+- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`\\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\\n+- Expose `cli-anything-<software>` through `console_scripts`\\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\\n+\\n+## Workflow\\n+\\n+1. Acquire the source tree locally (clone or use existing path).\\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\\n+3. Design command groups and state model.\\n+4. Implement the harness.\\n+5. Write `TEST.md`, then tests, then run them.\\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\\n+7. Verify local installation with `pip install -e .`\\n+\\n+## Existing Harnesses (Reference)\\n+\\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\\n+\\n+## Output Expectations\\n+\\n+When reporting progress or final results, include:\\n+\\n+- target software and source path\\n+- files added or changed\\n+- validation commands run\\n+- open risks or backend limitations\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Use Reasonix's registered shell and search tool names**\\n\\nThe adapter instructs its isolated subagent to call `bash` throughout implementation, testing, and packaging, but current Reasonix registers the shell tool as `run_command`; its corresponding search/list tools are `search_content` and `list_directory`, not `grep` and `ls`. Because a `runAs: subagent` skill receives this body as its operating instructions, following the documented workflow produces nonexistent-tool calls before it can install or test a harness. Update the bindings and phase instructions to use Reasonix's actual registered tool names.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"reasonix-skill/SKILL.md\",\n \"hunk\": \"@@ -0,0 +1,155 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\\n+---\\n+\\n+# CLI-Anything for Reasonix\\n+\\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\\n+\\n+Before implementation, use the full methodology source of truth when available:\\n+\\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\\n+\\n+## Inputs\\n+\\n+Accept either:\\n+\\n+- A local source path such as `./gimp` or `/path/to/software`\\n+- A GitHub repository URL\\n+\\n+Derive the software name from the local directory name after cloning if needed.\\n+\\n+## Reasonix Tool Bindings\\n+\\n+Reasonix agents build harnesses by combining these built-in tools:\\n+\\n+| Reasonix Tool | Role in Harness Workflow |\\n+|---------------|--------------------------|\\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\",\n \"resolving_sha\": \"d1eedc958e829593f6578739c6d0d4855913a523\",\n \"resolving_diff\": \"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\\nnew file mode 100644\\nindex 000000000..f24056e91\\n--- /dev/null\\n+++ b/reasonix-skill/SKILL.md\\n@@ -0,0 +1,164 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\\n+---\\n+\\n+# CLI-Anything for Reasonix\\n+\\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\\n+\\n+Before implementation, use the full methodology source of truth when available:\\n+\\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\\n+\\n+## Inputs\\n+\\n+Accept either:\\n+\\n+- A local source path such as `./gimp` or `/path/to/software`\\n+- A GitHub repository URL\\n+\\n+Derive the software name from the local directory name after cloning if needed.\\n+\\n+## Reasonix Tool Bindings\\n+\\n+Reasonix agents build harnesses by combining these built-in tools:\\n+\\n+| Reasonix Tool | Role in Harness Workflow |\\n+|---------------|--------------------------|\\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\\n+| `read_file` | Read target software source files, existing harness code, test results |\\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\\n+| `ls` | List directory contents to understand project structure |\\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\\n+\\n+### Recommended Workflow with Reasonix Tools\\n+\\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\\n+\\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\\n+\\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\\n+\\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\\n+\\n+## Step Budget\\n+\\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\\n+\\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\\n+\\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\\n+\\n+## Modes\\n+\\n+### Build\\n+\\n+Use when the user wants a new harness.\\n+\\n+Produce this structure:\\n+\\n+```text\\n+<repo-root>/\\n+├── skills/\\n+│ └── cli-anything-<software>/\\n+│ └── SKILL.md\\n+└── <software>/\\n+ └── agent-harness/\\n+ ├── <SOFTWARE>.md\\n+ ├── setup.py\\n+ └── cli_anything/\\n+ └── <software>/\\n+ ├── README.md\\n+ ├── __init__.py\\n+ ├── __main__.py\\n+ ├── <software>_cli.py\\n+ ├── core/\\n+ ├── utils/\\n+ ├── tests/\\n+ └── skills/\\n+ └── SKILL.md\\n+```\\n+\\n+Implement a stateful Click CLI with:\\n+\\n+- one-shot subcommands\\n+- REPL mode as the default when no subcommand is given\\n+- `--json` machine-readable output\\n+- session state with undo/redo where the target software supports it\\n+\\n+### Refine\\n+\\n+Use when the harness already exists.\\n+\\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\\n+\\n+- high-impact missing features\\n+- easy wrappers around existing backend APIs or CLIs\\n+- additions that compose well with existing commands\\n+\\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\\n+\\n+### Test\\n+\\n+Plan tests before writing them. Keep both:\\n+\\n+- `test_core.py` for unit coverage\\n+- `test_full_e2e.py` for workflow and backend validation\\n+\\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\\n+\\n+### Validate\\n+\\n+Check that the harness:\\n+\\n+- uses the `cli_anything.<software>` namespace package layout\\n+- has an installable `setup.py` entry point\\n+- supports JSON output\\n+- has a REPL default path\\n+- has matching canonical and package-local `SKILL.md` files\\n+- documents usage and tests\\n+\\n+## Backend Rules\\n+\\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\\n+\\n+## Packaging Rules\\n+\\n+- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`\\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\\n+- Expose `cli-anything-<software>` through `console_scripts`\\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\\n+\\n+## Workflow\\n+\\n+1. Acquire the source tree locally (clone or use existing path).\\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\\n+3. Design command groups and state model.\\n+4. Implement the harness.\\n+5. Write `TEST.md`, then tests, then run them.\\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\\n+7. Verify local installation with `pip install -e .`\\n+\\n+## Existing Harnesses (Reference)\\n+\\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\\n+\\n+## Output Expectations\\n+\\n+When reporting progress or final results, include:\\n+\\n+- target software and source path\\n+- files added or changed\\n+- validation commands run\\n+- open risks or backend limitations\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Invoke the skill through Reasonix's skill command**\\n\\nReasonix exposes user skills through `/skill <name>` (or the `run_skill` tool), and does not dynamically register `/cli-anything` as a slash command. Consequently, users following this primary usage example receive an unknown-command result instead of invoking the installed skill; document the command as `/skill cli-anything ...` and update the examples below accordingly.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"reasonix-skill/README.md\",\n \"hunk\": \"@@ -0,0 +1,107 @@\\n+# CLI-Anything for Reasonix\\n+\\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\\n+\\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\\n+\\n+## Installation\\n+\\n+**macOS / Linux:**\\n+\\n+```bash\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything/reasonix-skill\\n+./scripts/install.sh\\n+```\\n+\\n+**Windows (PowerShell):**\\n+\\n+```powershell\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything\\\\reasonix-skill\\n+.\\\\scripts\\\\install.ps1\\n+```\\n+\\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\\n+\\n+## Usage\\n+\\n+After installation, invoke the skill in any Reasonix session:\\n+\\n+```\\n+/cli-anything https://github.com/GNOME/gimp\",\n \"resolving_sha\": \"d1eedc958e829593f6578739c6d0d4855913a523\",\n \"resolving_diff\": \"diff --git a/reasonix-skill/README.md b/reasonix-skill/README.md\\nnew file mode 100644\\nindex 000000000..6233720ff\\n--- /dev/null\\n+++ b/reasonix-skill/README.md\\n@@ -0,0 +1,116 @@\\n+# CLI-Anything for Reasonix\\n+\\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\\n+\\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\\n+\\n+## Installation\\n+\\n+**macOS / Linux:**\\n+\\n+```bash\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything/reasonix-skill\\n+./scripts/install.sh\\n+```\\n+\\n+**Windows (PowerShell):**\\n+\\n+```powershell\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything\\\\reasonix-skill\\n+.\\\\scripts\\\\install.ps1\\n+```\\n+\\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\\n+\\n+## Configuration Note\\n+\\n+A full CLI-Anything build (architecture analysis, 10+ file generation, installation, and multiple test runs) typically requires 25–40 tool-call rounds. Reasonix's subagent step budget is derived from the `agent.max_steps` setting in `reasonix.toml`:\\n+\\n+- The default `max_steps = 0` means unlimited, which is recommended for this workflow.\\n+- If you have set `max_steps` to a finite value, the subagent receives half that budget (minimum 5), which may cause a build to be truncated before completion.\\n+\\n+To ensure builds complete successfully, set `agent.max_steps = 0` in your `reasonix.toml`, or use a sufficiently high value such as 64 or more.\\n+\\n+## Usage\\n+\\n+After installation, use slash invocation to inline the skill into the parent Reasonix loop:\\n+\\n+```\\n+/cli-anything https://github.com/GNOME/gimp\\n+```\\n+\\n+Use `run_skill` when you want isolated subagent execution. The same isolation applies when Reasonix invokes the skill through its dedicated subagent path:\\n+\\n+```\\n+run_skill({ name: \\\"cli-anything\\\", arguments: \\\"/path/to/software\\\" })\\n+```\\n+\\n+### What It Does\\n+\\n+The skill follows the CLI-Anything 7-phase methodology:\\n+\\n+1. **Codebase Analysis** — Surveys the target software's architecture, data model, and API surface\\n+2. **CLI Architecture Design** — Designs command groups, state model, and output formats\\n+3. **Implementation** — Generates a Click-based Python CLI with REPL, JSON output, and session state\\n+4. **Test Planning** — Creates TEST.md with comprehensive test plan\\n+5. **Test Implementation** — Writes unit tests and E2E tests with real backend invocation\\n+6. **Test Documentation** — Runs all tests and documents results\\n+7. **PyPI Packaging** — Creates setup.py and verifies `pip install -e .`\\n+\\n+### Example\\n+\\n+```bash\\n+# Build a CLI for GIMP from local source\\n+/cli-anything /home/user/gimp\\n+\\n+# Build from a GitHub repo\\n+/cli-anything https://github.com/blender/blender\\n+\\n+# Refine an existing harness\\n+/cli-anything /home/user/gimp \\\"Refine the existing harness for batch processing and Script-Fu filters\\\"\\n+```\\n+\\n+## Reasonix Tool Mapping\\n+\\n+| CLI-Anything Need | Reasonix Tool |\\n+|-------------------|---------------|\\n+| Shell execution | `bash` |\\n+| File generation | `write_file` |\\n+| Code editing | `edit_file` / `multi_edit` |\\n+| Source reading | `read_file` |\\n+| Codebase search | `grep` / `glob` / `ls` |\\n+| Architecture analysis | `mcp__codegraph__search` / `mcp__codegraph__context` when CodeGraph is enabled |\\n+| Documentation fetch | `web_fetch` |\\n+\\n+## File Structure\\n+\\n+```\\n+reasonix-skill/\\n+├── SKILL.md # Main skill document (methodology + tool bindings)\\n+├── README.md # This file\\n+├── agents/\\n+│ └── reasonix.yaml # Agent interface metadata\\n+└── scripts/\\n+ ├── install.sh # macOS/Linux installer\\n+ └── install.ps1 # Windows installer\\n+```\\n+\\n+## How It Compares to Other Agent Adapters\\n+\\n+| Feature | Claude Code | Codex | Hermes | **Reasonix** |\\n+|---------|------------|-------|--------|-------------|\\n+| Skill format | `.claude-plugin/` | `SKILL.md` + YAML | `SKILL.md` + YAML | `SKILL.md` + YAML |\\n+| Shell | `bash` | `terminal` | `terminal` | `bash` |\\n+| File ops | native | `execute_code` | `execute_code` / `write_file` | `write_file` / `edit_file` / `multi_edit` |\\n+| Code analysis | file reads | file reads | file reads | Optional `mcp__codegraph__search` / `mcp__codegraph__context` symbol graph |\\n+| Install method | `/plugin install` | `install.sh` → `$CODEX_HOME/skills/` | `install.sh` → `$HERMES_HOME/skills/` | `install.sh` → `~/.reasonix/skills/` |\\n+\\n+## Contributing\\n+\\n+This adapter follows the same contribution pattern as the Codex and Hermes adapters. See [CONTRIBUTING.md](../CONTRIBUTING.md) in the CLI-Anything repository.\\n+\\n+## License\\n+\\n+Apache License 2.0 — same as CLI-Anything.\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Raise the subagent iteration budget**\\n\\nWhen a build requires more than Reasonix's default 16 subagent iterations, the child loop stops before completing the harness; this workflow routinely needs architecture inspection, generation of 10+ files, installation, and multiple test runs. Reasonix documents `max-iters` as defaulting to 16 and allowing up to 32, so declare an appropriate `max-iters` value alongside `runAs: subagent` to avoid truncating the adapter's primary build workflow.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"reasonix-skill/SKILL.md\",\n \"hunk\": \"@@ -0,0 +1,155 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\",\n \"resolving_sha\": \"d1eedc958e829593f6578739c6d0d4855913a523\",\n \"resolving_diff\": \"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\\nnew file mode 100644\\nindex 000000000..f24056e91\\n--- /dev/null\\n+++ b/reasonix-skill/SKILL.md\\n@@ -0,0 +1,164 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\\n+---\\n+\\n+# CLI-Anything for Reasonix\\n+\\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\\n+\\n+Before implementation, use the full methodology source of truth when available:\\n+\\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\\n+\\n+## Inputs\\n+\\n+Accept either:\\n+\\n+- A local source path such as `./gimp` or `/path/to/software`\\n+- A GitHub repository URL\\n+\\n+Derive the software name from the local directory name after cloning if needed.\\n+\\n+## Reasonix Tool Bindings\\n+\\n+Reasonix agents build harnesses by combining these built-in tools:\\n+\\n+| Reasonix Tool | Role in Harness Workflow |\\n+|---------------|--------------------------|\\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\\n+| `read_file` | Read target software source files, existing harness code, test results |\\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\\n+| `ls` | List directory contents to understand project structure |\\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\\n+\\n+### Recommended Workflow with Reasonix Tools\\n+\\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\\n+\\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\\n+\\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\\n+\\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\\n+\\n+## Step Budget\\n+\\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\\n+\\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\\n+\\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\\n+\\n+## Modes\\n+\\n+### Build\\n+\\n+Use when the user wants a new harness.\\n+\\n+Produce this structure:\\n+\\n+```text\\n+<repo-root>/\\n+├── skills/\\n+│ └── cli-anything-<software>/\\n+│ └── SKILL.md\\n+└── <software>/\\n+ └── agent-harness/\\n+ ├── <SOFTWARE>.md\\n+ ├── setup.py\\n+ └── cli_anything/\\n+ └── <software>/\\n+ ├── README.md\\n+ ├── __init__.py\\n+ ├── __main__.py\\n+ ├── <software>_cli.py\\n+ ├── core/\\n+ ├── utils/\\n+ ├── tests/\\n+ └── skills/\\n+ └── SKILL.md\\n+```\\n+\\n+Implement a stateful Click CLI with:\\n+\\n+- one-shot subcommands\\n+- REPL mode as the default when no subcommand is given\\n+- `--json` machine-readable output\\n+- session state with undo/redo where the target software supports it\\n+\\n+### Refine\\n+\\n+Use when the harness already exists.\\n+\\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\\n+\\n+- high-impact missing features\\n+- easy wrappers around existing backend APIs or CLIs\\n+- additions that compose well with existing commands\\n+\\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\\n+\\n+### Test\\n+\\n+Plan tests before writing them. Keep both:\\n+\\n+- `test_core.py` for unit coverage\\n+- `test_full_e2e.py` for workflow and backend validation\\n+\\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\\n+\\n+### Validate\\n+\\n+Check that the harness:\\n+\\n+- uses the `cli_anything.<software>` namespace package layout\\n+- has an installable `setup.py` entry point\\n+- supports JSON output\\n+- has a REPL default path\\n+- has matching canonical and package-local `SKILL.md` files\\n+- documents usage and tests\\n+\\n+## Backend Rules\\n+\\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\\n+\\n+## Packaging Rules\\n+\\n+- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`\\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\\n+- Expose `cli-anything-<software>` through `console_scripts`\\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\\n+\\n+## Workflow\\n+\\n+1. Acquire the source tree locally (clone or use existing path).\\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\\n+3. Design command groups and state model.\\n+4. Implement the harness.\\n+5. Write `TEST.md`, then tests, then run them.\\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\\n+7. Verify local installation with `pip install -e .`\\n+\\n+## Existing Harnesses (Reference)\\n+\\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\\n+\\n+## Output Expectations\\n+\\n+When reporting progress or final results, include:\\n+\\n+- target software and source path\\n+- files added or changed\\n+- validation commands run\\n+- open risks or backend limitations\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4829,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":344,"string":"344"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"feat: add Reasonix agent skill adapter"},"pr_body":{"kind":"string","value":"**<sub><sub></sub></sub> Declare the skill as a subagent in frontmatter**\n\nFor the shell/PowerShell install path, Reasonix loads this `SKILL.md` directly from `~/.reasonix/skills/cli-anything/SKILL.md`; Reasonix's skill docs say `runAs` defaults to `inline` and only `runAs: subagent` runs the body in an isolated child loop. Because the adapter documentation and README promise this skill spawns an isolated sub-agent, users who install via the bundled scripts will instead run the whole CLI-Anything workflow inline in their parent session unless the frontmatter includes `runAs: subagent`.\n\nUseful? React with 👍 / 👎."},"base_sha":{"kind":"string","value":"f23e051a053dfe34737f3d542f9fb3952d23922d"},"head_sha":{"kind":"string","value":"d1eedc958e829593f6578739c6d0d4855913a523"},"gold_diff":{"kind":"string","value":"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\n"},"changed_files":{"kind":"list like","value":["reasonix-skill/SKILL.md"],"string":"[\n \"reasonix-skill/SKILL.md\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"**<sub><sub></sub></sub> Declare the skill as a subagent in frontmatter**\n\nFor the shell/PowerShell install path, Reasonix loads this `SKILL.md` directly from `~/.reasonix/skills/cli-anything/SKILL.md`; Reasonix's skill docs say `runAs` defaults to `inline` and only `runAs: subagent` runs the body in an isolated child loop. Because the adapter documentation and README promise this skill spawns an isolated sub-agent, users who install via the bundled scripts will instead run the whole CLI-Anything workflow inline in their parent session unless the frontmatter includes `runAs: subagent`.\n\nUseful? React with 👍 / 👎.","path":"reasonix-skill/SKILL.md","hunk":"@@ -0,0 +1,146 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+---","resolving_sha":"d1eedc958e829593f6578739c6d0d4855913a523","resolving_diff":"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\n"}],"string":"[\n {\n \"comment\": \"**<sub><sub></sub></sub> Declare the skill as a subagent in frontmatter**\\n\\nFor the shell/PowerShell install path, Reasonix loads this `SKILL.md` directly from `~/.reasonix/skills/cli-anything/SKILL.md`; Reasonix's skill docs say `runAs` defaults to `inline` and only `runAs: subagent` runs the body in an isolated child loop. Because the adapter documentation and README promise this skill spawns an isolated sub-agent, users who install via the bundled scripts will instead run the whole CLI-Anything workflow inline in their parent session unless the frontmatter includes `runAs: subagent`.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"reasonix-skill/SKILL.md\",\n \"hunk\": \"@@ -0,0 +1,146 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+---\",\n \"resolving_sha\": \"d1eedc958e829593f6578739c6d0d4855913a523\",\n \"resolving_diff\": \"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\\nnew file mode 100644\\nindex 000000000..f24056e91\\n--- /dev/null\\n+++ b/reasonix-skill/SKILL.md\\n@@ -0,0 +1,164 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\\n+---\\n+\\n+# CLI-Anything for Reasonix\\n+\\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\\n+\\n+Before implementation, use the full methodology source of truth when available:\\n+\\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\\n+\\n+## Inputs\\n+\\n+Accept either:\\n+\\n+- A local source path such as `./gimp` or `/path/to/software`\\n+- A GitHub repository URL\\n+\\n+Derive the software name from the local directory name after cloning if needed.\\n+\\n+## Reasonix Tool Bindings\\n+\\n+Reasonix agents build harnesses by combining these built-in tools:\\n+\\n+| Reasonix Tool | Role in Harness Workflow |\\n+|---------------|--------------------------|\\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\\n+| `read_file` | Read target software source files, existing harness code, test results |\\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\\n+| `ls` | List directory contents to understand project structure |\\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\\n+\\n+### Recommended Workflow with Reasonix Tools\\n+\\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\\n+\\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\\n+\\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\\n+\\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\\n+\\n+## Step Budget\\n+\\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\\n+\\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\\n+\\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\\n+\\n+## Modes\\n+\\n+### Build\\n+\\n+Use when the user wants a new harness.\\n+\\n+Produce this structure:\\n+\\n+```text\\n+<repo-root>/\\n+├── skills/\\n+│ └── cli-anything-<software>/\\n+│ └── SKILL.md\\n+└── <software>/\\n+ └── agent-harness/\\n+ ├── <SOFTWARE>.md\\n+ ├── setup.py\\n+ └── cli_anything/\\n+ └── <software>/\\n+ ├── README.md\\n+ ├── __init__.py\\n+ ├── __main__.py\\n+ ├── <software>_cli.py\\n+ ├── core/\\n+ ├── utils/\\n+ ├── tests/\\n+ └── skills/\\n+ └── SKILL.md\\n+```\\n+\\n+Implement a stateful Click CLI with:\\n+\\n+- one-shot subcommands\\n+- REPL mode as the default when no subcommand is given\\n+- `--json` machine-readable output\\n+- session state with undo/redo where the target software supports it\\n+\\n+### Refine\\n+\\n+Use when the harness already exists.\\n+\\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\\n+\\n+- high-impact missing features\\n+- easy wrappers around existing backend APIs or CLIs\\n+- additions that compose well with existing commands\\n+\\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\\n+\\n+### Test\\n+\\n+Plan tests before writing them. Keep both:\\n+\\n+- `test_core.py` for unit coverage\\n+- `test_full_e2e.py` for workflow and backend validation\\n+\\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\\n+\\n+### Validate\\n+\\n+Check that the harness:\\n+\\n+- uses the `cli_anything.<software>` namespace package layout\\n+- has an installable `setup.py` entry point\\n+- supports JSON output\\n+- has a REPL default path\\n+- has matching canonical and package-local `SKILL.md` files\\n+- documents usage and tests\\n+\\n+## Backend Rules\\n+\\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\\n+\\n+## Packaging Rules\\n+\\n+- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`\\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\\n+- Expose `cli-anything-<software>` through `console_scripts`\\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\\n+\\n+## Workflow\\n+\\n+1. Acquire the source tree locally (clone or use existing path).\\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\\n+3. Design command groups and state model.\\n+4. Implement the harness.\\n+5. Write `TEST.md`, then tests, then run them.\\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\\n+7. Verify local installation with `pip install -e .`\\n+\\n+## Existing Harnesses (Reference)\\n+\\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\\n+\\n+## Output Expectations\\n+\\n+When reporting progress or final results, include:\\n+\\n+- target software and source path\\n+- files added or changed\\n+- validation commands run\\n+- open risks or backend limitations\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4830,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":344,"string":"344"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"feat: add Reasonix agent skill adapter"},"pr_body":{"kind":"string","value":"**<sub><sub></sub></sub> Use Reasonix's registered shell and search tool names**\n\nThe adapter instructs its isolated subagent to call `bash` throughout implementation, testing, and packaging, but current Reasonix registers the shell tool as `run_command`; its corresponding search/list tools are `search_content` and `list_directory`, not `grep` and `ls`. Because a `runAs: subagent` skill receives this body as its operating instructions, following the documented workflow produces nonexistent-tool calls before it can install or test a harness. Update the bindings and phase instructions to use Reasonix's actual registered tool names.\n\nUseful? React with 👍 / 👎."},"base_sha":{"kind":"string","value":"f23e051a053dfe34737f3d542f9fb3952d23922d"},"head_sha":{"kind":"string","value":"d1eedc958e829593f6578739c6d0d4855913a523"},"gold_diff":{"kind":"string","value":"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\n"},"changed_files":{"kind":"list like","value":["reasonix-skill/SKILL.md"],"string":"[\n \"reasonix-skill/SKILL.md\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"**<sub><sub></sub></sub> Use Reasonix's registered shell and search tool names**\n\nThe adapter instructs its isolated subagent to call `bash` throughout implementation, testing, and packaging, but current Reasonix registers the shell tool as `run_command`; its corresponding search/list tools are `search_content` and `list_directory`, not `grep` and `ls`. Because a `runAs: subagent` skill receives this body as its operating instructions, following the documented workflow produces nonexistent-tool calls before it can install or test a harness. Update the bindings and phase instructions to use Reasonix's actual registered tool names.\n\nUseful? React with 👍 / 👎.","path":"reasonix-skill/SKILL.md","hunk":"@@ -0,0 +1,155 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |","resolving_sha":"d1eedc958e829593f6578739c6d0d4855913a523","resolving_diff":"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\nnew file mode 100644\nindex 000000000..f24056e91\n--- /dev/null\n+++ b/reasonix-skill/SKILL.md\n@@ -0,0 +1,164 @@\n+---\n+name: cli-anything\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\n+runAs: subagent\n+---\n+\n+# CLI-Anything for Reasonix\n+\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\n+\n+Before implementation, use the full methodology source of truth when available:\n+\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\n+\n+## Inputs\n+\n+Accept either:\n+\n+- A local source path such as `./gimp` or `/path/to/software`\n+- A GitHub repository URL\n+\n+Derive the software name from the local directory name after cloning if needed.\n+\n+## Reasonix Tool Bindings\n+\n+Reasonix agents build harnesses by combining these built-in tools:\n+\n+| Reasonix Tool | Role in Harness Workflow |\n+|---------------|--------------------------|\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\n+| `read_file` | Read target software source files, existing harness code, test results |\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\n+| `ls` | List directory contents to understand project structure |\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\n+\n+### Recommended Workflow with Reasonix Tools\n+\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\n+\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\n+\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\n+\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\n+\n+## Step Budget\n+\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\n+\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\n+\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\n+\n+## Modes\n+\n+### Build\n+\n+Use when the user wants a new harness.\n+\n+Produce this structure:\n+\n+```text\n+<repo-root>/\n+├── skills/\n+│ └── cli-anything-<software>/\n+│ └── SKILL.md\n+└── <software>/\n+ └── agent-harness/\n+ ├── <SOFTWARE>.md\n+ ├── setup.py\n+ └── cli_anything/\n+ └── <software>/\n+ ├── README.md\n+ ├── __init__.py\n+ ├── __main__.py\n+ ├── <software>_cli.py\n+ ├── core/\n+ ├── utils/\n+ ├── tests/\n+ └── skills/\n+ └── SKILL.md\n+```\n+\n+Implement a stateful Click CLI with:\n+\n+- one-shot subcommands\n+- REPL mode as the default when no subcommand is given\n+- `--json` machine-readable output\n+- session state with undo/redo where the target software supports it\n+\n+### Refine\n+\n+Use when the harness already exists.\n+\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n+\n+- high-impact missing features\n+- easy wrappers around existing backend APIs or CLIs\n+- additions that compose well with existing commands\n+\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\n+\n+### Test\n+\n+Plan tests before writing them. Keep both:\n+\n+- `test_core.py` for unit coverage\n+- `test_full_e2e.py` for workflow and backend validation\n+\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n+\n+### Validate\n+\n+Check that the harness:\n+\n+- uses the `cli_anything.<software>` namespace package layout\n+- has an installable `setup.py` entry point\n+- supports JSON output\n+- has a REPL default path\n+- has matching canonical and package-local `SKILL.md` files\n+- documents usage and tests\n+\n+## Backend Rules\n+\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n+\n+## Packaging Rules\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n+- Expose `cli-anything-<software>` through `console_scripts`\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\n+\n+## Workflow\n+\n+1. Acquire the source tree locally (clone or use existing path).\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n+3. Design command groups and state model.\n+4. Implement the harness.\n+5. Write `TEST.md`, then tests, then run them.\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\n+7. Verify local installation with `pip install -e .`\n+\n+## Existing Harnesses (Reference)\n+\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\n+\n+## Output Expectations\n+\n+When reporting progress or final results, include:\n+\n+- target software and source path\n+- files added or changed\n+- validation commands run\n+- open risks or backend limitations\n"}],"string":"[\n {\n \"comment\": \"**<sub><sub></sub></sub> Use Reasonix's registered shell and search tool names**\\n\\nThe adapter instructs its isolated subagent to call `bash` throughout implementation, testing, and packaging, but current Reasonix registers the shell tool as `run_command`; its corresponding search/list tools are `search_content` and `list_directory`, not `grep` and `ls`. Because a `runAs: subagent` skill receives this body as its operating instructions, following the documented workflow produces nonexistent-tool calls before it can install or test a harness. Update the bindings and phase instructions to use Reasonix's actual registered tool names.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"reasonix-skill/SKILL.md\",\n \"hunk\": \"@@ -0,0 +1,155 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\\n+---\\n+\\n+# CLI-Anything for Reasonix\\n+\\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\\n+\\n+Before implementation, use the full methodology source of truth when available:\\n+\\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\\n+\\n+## Inputs\\n+\\n+Accept either:\\n+\\n+- A local source path such as `./gimp` or `/path/to/software`\\n+- A GitHub repository URL\\n+\\n+Derive the software name from the local directory name after cloning if needed.\\n+\\n+## Reasonix Tool Bindings\\n+\\n+Reasonix agents build harnesses by combining these built-in tools:\\n+\\n+| Reasonix Tool | Role in Harness Workflow |\\n+|---------------|--------------------------|\\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\",\n \"resolving_sha\": \"d1eedc958e829593f6578739c6d0d4855913a523\",\n \"resolving_diff\": \"diff --git a/reasonix-skill/SKILL.md b/reasonix-skill/SKILL.md\\nnew file mode 100644\\nindex 000000000..f24056e91\\n--- /dev/null\\n+++ b/reasonix-skill/SKILL.md\\n@@ -0,0 +1,164 @@\\n+---\\n+name: cli-anything\\n+description: Use when the user wants Reasonix to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Reasonix without changing the generated Python harness format.\\n+runAs: subagent\\n+---\\n+\\n+# CLI-Anything for Reasonix\\n+\\n+Use this skill when the user wants Reasonix to act like the `CLI-Anything` builder.\\n+\\n+Before implementation, use the full methodology source of truth when available:\\n+\\n+1. If the current workspace is the `CLI-Anything` repository, read `cli-anything-plugin/HARNESS.md`.\\n+2. If Reasonix is running from this adapter directory, also check `../cli-anything-plugin/HARNESS.md`.\\n+3. If neither local file is available, clone or download `cli-anything-plugin` from `https://github.com/HKUDS/CLI-Anything/tree/main/cli-anything-plugin`, then use `HARNESS.md` and the resources around it from that folder.\\n+4. Only if local and network retrieval both fail, follow the condensed rules below.\\n+\\n+## Inputs\\n+\\n+Accept either:\\n+\\n+- A local source path such as `./gimp` or `/path/to/software`\\n+- A GitHub repository URL\\n+\\n+Derive the software name from the local directory name after cloning if needed.\\n+\\n+## Reasonix Tool Bindings\\n+\\n+Reasonix agents build harnesses by combining these built-in tools:\\n+\\n+| Reasonix Tool | Role in Harness Workflow |\\n+|---------------|--------------------------|\\n+| `bash` | Run shell commands, install packages, execute CLI tools, run tests, clone repos |\\n+| `write_file` | Generate Python files (Click CLI, backend modules, tests, setup.py) |\\n+| `edit_file` | Make targeted edits to generated code (single replacement) |\\n+| `multi_edit` | Apply multiple atomic edits to a single file in one pass |\\n+| `read_file` | Read target software source files, existing harness code, test results |\\n+| `grep` | Search for patterns across the target software codebase (APIs, CLI tools, data models) |\\n+| `glob` | Find files matching patterns in the source tree (*.py, *.xml, *.json, etc.) |\\n+| `ls` | List directory contents to understand project structure |\\n+| `mcp__codegraph__search` / `mcp__codegraph__context` | Optional code graph analysis when CodeGraph is enabled (Reasonix strips the `codegraph_` raw prefix, so the model-visible names omit it) |\\n+| `web_fetch` | Fetch documentation, API references, or remote files from the web |\\n+\\n+### Recommended Workflow with Reasonix Tools\\n+\\n+**Phase 1 (Analysis)** — Use `ls` + `glob` to survey the source tree, `grep` to find API surfaces and CLI entry points, and `read_file` to inspect key files. When CodeGraph is enabled and its tools are available, use `mcp__codegraph__search` and `mcp__codegraph__context` for deeper symbol and architecture analysis.\\n+\\n+**Phase 2-3 (Design & Implementation)** — Use `write_file` to create new harness files, `edit_file` / `multi_edit` to refine generated code, and `bash` to run `pip install -e .` for installation.\\n+\\n+**Phase 4-6 (Testing)** — Use `bash` to run `pytest` and capture results, `read_file` to inspect test output, and `write_file` to update TEST.md.\\n+\\n+**Phase 7 (Packaging)** — Use `write_file` for setup.py, `bash` for `pip install -e .` and `which cli-anything-<software>` verification.\\n+\\n+## Step Budget\\n+\\n+A full harness build typically requires 25–40 tool-call rounds (architecture inspection, 10+ file writes, installation, and multiple test runs). When invoked via `run_skill`, the subagent inherits a step budget derived from the parent agent's `agent.max_steps` setting in `reasonix.toml`:\\n+\\n+- If `max_steps = 0` (the default, meaning unlimited), the subagent also runs with no step cap — this is the recommended configuration for the CLI-Anything workflow.\\n+- If `max_steps` is set to a finite value, the subagent receives half that budget (minimum 5), which may truncate a complex build before completion.\\n+\\n+Users who have configured a finite `max_steps` should ensure it is set to 0 or a sufficiently high value (e.g., 64 or more) before running a CLI-Anything build, so the subagent has enough rounds to complete all seven phases.\\n+\\n+## Modes\\n+\\n+### Build\\n+\\n+Use when the user wants a new harness.\\n+\\n+Produce this structure:\\n+\\n+```text\\n+<repo-root>/\\n+├── skills/\\n+│ └── cli-anything-<software>/\\n+│ └── SKILL.md\\n+└── <software>/\\n+ └── agent-harness/\\n+ ├── <SOFTWARE>.md\\n+ ├── setup.py\\n+ └── cli_anything/\\n+ └── <software>/\\n+ ├── README.md\\n+ ├── __init__.py\\n+ ├── __main__.py\\n+ ├── <software>_cli.py\\n+ ├── core/\\n+ ├── utils/\\n+ ├── tests/\\n+ └── skills/\\n+ └── SKILL.md\\n+```\\n+\\n+Implement a stateful Click CLI with:\\n+\\n+- one-shot subcommands\\n+- REPL mode as the default when no subcommand is given\\n+- `--json` machine-readable output\\n+- session state with undo/redo where the target software supports it\\n+\\n+### Refine\\n+\\n+Use when the harness already exists.\\n+\\n+First inventory current commands and tests, then do gap analysis against the target software. Prefer:\\n+\\n+- high-impact missing features\\n+- easy wrappers around existing backend APIs or CLIs\\n+- additions that compose well with existing commands\\n+\\n+Do not remove existing commands unless the user explicitly asks for a breaking change.\\n+\\n+### Test\\n+\\n+Plan tests before writing them. Keep both:\\n+\\n+- `test_core.py` for unit coverage\\n+- `test_full_e2e.py` for workflow and backend validation\\n+\\n+When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\\n+\\n+### Validate\\n+\\n+Check that the harness:\\n+\\n+- uses the `cli_anything.<software>` namespace package layout\\n+- has an installable `setup.py` entry point\\n+- supports JSON output\\n+- has a REPL default path\\n+- has matching canonical and package-local `SKILL.md` files\\n+- documents usage and tests\\n+\\n+## Backend Rules\\n+\\n+Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\\n+\\n+## Packaging Rules\\n+\\n+- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`\\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\\n+- Expose `cli-anything-<software>` through `console_scripts`\\n+- Include `cli_anything.<software>/skills/SKILL.md` in package data\\n+\\n+## Workflow\\n+\\n+1. Acquire the source tree locally (clone or use existing path).\\n+2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\\n+3. Design command groups and state model.\\n+4. Implement the harness.\\n+5. Write `TEST.md`, then tests, then run them.\\n+6. Update README usage docs and generate both `skills/cli-anything-<software>/SKILL.md` and `cli_anything/<software>/skills/SKILL.md`.\\n+7. Verify local installation with `pip install -e .`\\n+\\n+## Existing Harnesses (Reference)\\n+\\n+For an up-to-date list of supported harnesses and their backend patterns, locate `registry.json` at the `CLI-Anything` repository root when it is available.\\n+\\n+## Output Expectations\\n+\\n+When reporting progress or final results, include:\\n+\\n+- target software and source path\\n+- files added or changed\\n+- validation commands run\\n+- open risks or backend limitations\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4831,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":344,"string":"344"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"feat: add Reasonix agent skill adapter"},"pr_body":{"kind":"string","value":"**<sub><sub></sub></sub> Invoke the skill through Reasonix's skill command**\n\nReasonix exposes user skills through `/skill <name>` (or the `run_skill` tool), and does not dynamically register `/cli-anything` as a slash command. Consequently, users following this primary usage example receive an unknown-command result instead of invoking the installed skill; document the command as `/skill cli-anything ...` and update the examples below accordingly.\n\nUseful? React with 👍 / 👎."},"base_sha":{"kind":"string","value":"f23e051a053dfe34737f3d542f9fb3952d23922d"},"head_sha":{"kind":"string","value":"d1eedc958e829593f6578739c6d0d4855913a523"},"gold_diff":{"kind":"string","value":"diff --git a/reasonix-skill/README.md b/reasonix-skill/README.md\nnew file mode 100644\nindex 000000000..6233720ff\n--- /dev/null\n+++ b/reasonix-skill/README.md\n@@ -0,0 +1,116 @@\n+# CLI-Anything for Reasonix\n+\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\n+\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\n+\n+## Installation\n+\n+**macOS / Linux:**\n+\n+```bash\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything/reasonix-skill\n+./scripts/install.sh\n+```\n+\n+**Windows (PowerShell):**\n+\n+```powershell\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything\\reasonix-skill\n+.\\scripts\\install.ps1\n+```\n+\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\n+\n+## Configuration Note\n+\n+A full CLI-Anything build (architecture analysis, 10+ file generation, installation, and multiple test runs) typically requires 25–40 tool-call rounds. Reasonix's subagent step budget is derived from the `agent.max_steps` setting in `reasonix.toml`:\n+\n+- The default `max_steps = 0` means unlimited, which is recommended for this workflow.\n+- If you have set `max_steps` to a finite value, the subagent receives half that budget (minimum 5), which may cause a build to be truncated before completion.\n+\n+To ensure builds complete successfully, set `agent.max_steps = 0` in your `reasonix.toml`, or use a sufficiently high value such as 64 or more.\n+\n+## Usage\n+\n+After installation, use slash invocation to inline the skill into the parent Reasonix loop:\n+\n+```\n+/cli-anything https://github.com/GNOME/gimp\n+```\n+\n+Use `run_skill` when you want isolated subagent execution. The same isolation applies when Reasonix invokes the skill through its dedicated subagent path:\n+\n+```\n+run_skill({ name: \"cli-anything\", arguments: \"/path/to/software\" })\n+```\n+\n+### What It Does\n+\n+The skill follows the CLI-Anything 7-phase methodology:\n+\n+1. **Codebase Analysis** — Surveys the target software's architecture, data model, and API surface\n+2. **CLI Architecture Design** — Designs command groups, state model, and output formats\n+3. **Implementation** — Generates a Click-based Python CLI with REPL, JSON output, and session state\n+4. **Test Planning** — Creates TEST.md with comprehensive test plan\n+5. **Test Implementation** — Writes unit tests and E2E tests with real backend invocation\n+6. **Test Documentation** — Runs all tests and documents results\n+7. **PyPI Packaging** — Creates setup.py and verifies `pip install -e .`\n+\n+### Example\n+\n+```bash\n+# Build a CLI for GIMP from local source\n+/cli-anything /home/user/gimp\n+\n+# Build from a GitHub repo\n+/cli-anything https://github.com/blender/blender\n+\n+# Refine an existing harness\n+/cli-anything /home/user/gimp \"Refine the existing harness for batch processing and Script-Fu filters\"\n+```\n+\n+## Reasonix Tool Mapping\n+\n+| CLI-Anything Need | Reasonix Tool |\n+|-------------------|---------------|\n+| Shell execution | `bash` |\n+| File generation | `write_file` |\n+| Code editing | `edit_file` / `multi_edit` |\n+| Source reading | `read_file` |\n+| Codebase search | `grep` / `glob` / `ls` |\n+| Architecture analysis | `mcp__codegraph__search` / `mcp__codegraph__context` when CodeGraph is enabled |\n+| Documentation fetch | `web_fetch` |\n+\n+## File Structure\n+\n+```\n+reasonix-skill/\n+├── SKILL.md # Main skill document (methodology + tool bindings)\n+├── README.md # This file\n+├── agents/\n+│ └── reasonix.yaml # Agent interface metadata\n+└── scripts/\n+ ├── install.sh # macOS/Linux installer\n+ └── install.ps1 # Windows installer\n+```\n+\n+## How It Compares to Other Agent Adapters\n+\n+| Feature | Claude Code | Codex | Hermes | **Reasonix** |\n+|---------|------------|-------|--------|-------------|\n+| Skill format | `.claude-plugin/` | `SKILL.md` + YAML | `SKILL.md` + YAML | `SKILL.md` + YAML |\n+| Shell | `bash` | `terminal` | `terminal` | `bash` |\n+| File ops | native | `execute_code` | `execute_code` / `write_file` | `write_file` / `edit_file` / `multi_edit` |\n+| Code analysis | file reads | file reads | file reads | Optional `mcp__codegraph__search` / `mcp__codegraph__context` symbol graph |\n+| Install method | `/plugin install` | `install.sh` → `$CODEX_HOME/skills/` | `install.sh` → `$HERMES_HOME/skills/` | `install.sh` → `~/.reasonix/skills/` |\n+\n+## Contributing\n+\n+This adapter follows the same contribution pattern as the Codex and Hermes adapters. See [CONTRIBUTING.md](../CONTRIBUTING.md) in the CLI-Anything repository.\n+\n+## License\n+\n+Apache License 2.0 — same as CLI-Anything.\n"},"changed_files":{"kind":"list like","value":["reasonix-skill/README.md"],"string":"[\n \"reasonix-skill/README.md\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"**<sub><sub></sub></sub> Invoke the skill through Reasonix's skill command**\n\nReasonix exposes user skills through `/skill <name>` (or the `run_skill` tool), and does not dynamically register `/cli-anything` as a slash command. Consequently, users following this primary usage example receive an unknown-command result instead of invoking the installed skill; document the command as `/skill cli-anything ...` and update the examples below accordingly.\n\nUseful? React with 👍 / 👎.","path":"reasonix-skill/README.md","hunk":"@@ -0,0 +1,107 @@\n+# CLI-Anything for Reasonix\n+\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\n+\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\n+\n+## Installation\n+\n+**macOS / Linux:**\n+\n+```bash\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything/reasonix-skill\n+./scripts/install.sh\n+```\n+\n+**Windows (PowerShell):**\n+\n+```powershell\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything\\reasonix-skill\n+.\\scripts\\install.ps1\n+```\n+\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\n+\n+## Usage\n+\n+After installation, invoke the skill in any Reasonix session:\n+\n+```\n+/cli-anything https://github.com/GNOME/gimp","resolving_sha":"d1eedc958e829593f6578739c6d0d4855913a523","resolving_diff":"diff --git a/reasonix-skill/README.md b/reasonix-skill/README.md\nnew file mode 100644\nindex 000000000..6233720ff\n--- /dev/null\n+++ b/reasonix-skill/README.md\n@@ -0,0 +1,116 @@\n+# CLI-Anything for Reasonix\n+\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\n+\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\n+\n+## Installation\n+\n+**macOS / Linux:**\n+\n+```bash\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything/reasonix-skill\n+./scripts/install.sh\n+```\n+\n+**Windows (PowerShell):**\n+\n+```powershell\n+git clone https://github.com/HKUDS/CLI-Anything.git\n+cd CLI-Anything\\reasonix-skill\n+.\\scripts\\install.ps1\n+```\n+\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\n+\n+## Configuration Note\n+\n+A full CLI-Anything build (architecture analysis, 10+ file generation, installation, and multiple test runs) typically requires 25–40 tool-call rounds. Reasonix's subagent step budget is derived from the `agent.max_steps` setting in `reasonix.toml`:\n+\n+- The default `max_steps = 0` means unlimited, which is recommended for this workflow.\n+- If you have set `max_steps` to a finite value, the subagent receives half that budget (minimum 5), which may cause a build to be truncated before completion.\n+\n+To ensure builds complete successfully, set `agent.max_steps = 0` in your `reasonix.toml`, or use a sufficiently high value such as 64 or more.\n+\n+## Usage\n+\n+After installation, use slash invocation to inline the skill into the parent Reasonix loop:\n+\n+```\n+/cli-anything https://github.com/GNOME/gimp\n+```\n+\n+Use `run_skill` when you want isolated subagent execution. The same isolation applies when Reasonix invokes the skill through its dedicated subagent path:\n+\n+```\n+run_skill({ name: \"cli-anything\", arguments: \"/path/to/software\" })\n+```\n+\n+### What It Does\n+\n+The skill follows the CLI-Anything 7-phase methodology:\n+\n+1. **Codebase Analysis** — Surveys the target software's architecture, data model, and API surface\n+2. **CLI Architecture Design** — Designs command groups, state model, and output formats\n+3. **Implementation** — Generates a Click-based Python CLI with REPL, JSON output, and session state\n+4. **Test Planning** — Creates TEST.md with comprehensive test plan\n+5. **Test Implementation** — Writes unit tests and E2E tests with real backend invocation\n+6. **Test Documentation** — Runs all tests and documents results\n+7. **PyPI Packaging** — Creates setup.py and verifies `pip install -e .`\n+\n+### Example\n+\n+```bash\n+# Build a CLI for GIMP from local source\n+/cli-anything /home/user/gimp\n+\n+# Build from a GitHub repo\n+/cli-anything https://github.com/blender/blender\n+\n+# Refine an existing harness\n+/cli-anything /home/user/gimp \"Refine the existing harness for batch processing and Script-Fu filters\"\n+```\n+\n+## Reasonix Tool Mapping\n+\n+| CLI-Anything Need | Reasonix Tool |\n+|-------------------|---------------|\n+| Shell execution | `bash` |\n+| File generation | `write_file` |\n+| Code editing | `edit_file` / `multi_edit` |\n+| Source reading | `read_file` |\n+| Codebase search | `grep` / `glob` / `ls` |\n+| Architecture analysis | `mcp__codegraph__search` / `mcp__codegraph__context` when CodeGraph is enabled |\n+| Documentation fetch | `web_fetch` |\n+\n+## File Structure\n+\n+```\n+reasonix-skill/\n+├── SKILL.md # Main skill document (methodology + tool bindings)\n+├── README.md # This file\n+├── agents/\n+│ └── reasonix.yaml # Agent interface metadata\n+└── scripts/\n+ ├── install.sh # macOS/Linux installer\n+ └── install.ps1 # Windows installer\n+```\n+\n+## How It Compares to Other Agent Adapters\n+\n+| Feature | Claude Code | Codex | Hermes | **Reasonix** |\n+|---------|------------|-------|--------|-------------|\n+| Skill format | `.claude-plugin/` | `SKILL.md` + YAML | `SKILL.md` + YAML | `SKILL.md` + YAML |\n+| Shell | `bash` | `terminal` | `terminal` | `bash` |\n+| File ops | native | `execute_code` | `execute_code` / `write_file` | `write_file` / `edit_file` / `multi_edit` |\n+| Code analysis | file reads | file reads | file reads | Optional `mcp__codegraph__search` / `mcp__codegraph__context` symbol graph |\n+| Install method | `/plugin install` | `install.sh` → `$CODEX_HOME/skills/` | `install.sh` → `$HERMES_HOME/skills/` | `install.sh` → `~/.reasonix/skills/` |\n+\n+## Contributing\n+\n+This adapter follows the same contribution pattern as the Codex and Hermes adapters. See [CONTRIBUTING.md](../CONTRIBUTING.md) in the CLI-Anything repository.\n+\n+## License\n+\n+Apache License 2.0 — same as CLI-Anything.\n"}],"string":"[\n {\n \"comment\": \"**<sub><sub></sub></sub> Invoke the skill through Reasonix's skill command**\\n\\nReasonix exposes user skills through `/skill <name>` (or the `run_skill` tool), and does not dynamically register `/cli-anything` as a slash command. Consequently, users following this primary usage example receive an unknown-command result instead of invoking the installed skill; document the command as `/skill cli-anything ...` and update the examples below accordingly.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"reasonix-skill/README.md\",\n \"hunk\": \"@@ -0,0 +1,107 @@\\n+# CLI-Anything for Reasonix\\n+\\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\\n+\\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\\n+\\n+## Installation\\n+\\n+**macOS / Linux:**\\n+\\n+```bash\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything/reasonix-skill\\n+./scripts/install.sh\\n+```\\n+\\n+**Windows (PowerShell):**\\n+\\n+```powershell\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything\\\\reasonix-skill\\n+.\\\\scripts\\\\install.ps1\\n+```\\n+\\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\\n+\\n+## Usage\\n+\\n+After installation, invoke the skill in any Reasonix session:\\n+\\n+```\\n+/cli-anything https://github.com/GNOME/gimp\",\n \"resolving_sha\": \"d1eedc958e829593f6578739c6d0d4855913a523\",\n \"resolving_diff\": \"diff --git a/reasonix-skill/README.md b/reasonix-skill/README.md\\nnew file mode 100644\\nindex 000000000..6233720ff\\n--- /dev/null\\n+++ b/reasonix-skill/README.md\\n@@ -0,0 +1,116 @@\\n+# CLI-Anything for Reasonix\\n+\\n+An adapter that brings the [CLI-Anything](https://github.com/HKUDS/CLI-Anything) harness methodology to the [Reasonix](https://github.com/esengine/DeepSeek-Reasonix) coding agent.\\n+\\n+CLI-Anything is a methodology for making **any GUI software agent-native** by generating stateful CLI harnesses with REPL mode, JSON output, undo/redo, and comprehensive tests. This adapter lets Reasonix act as the builder agent.\\n+\\n+## Installation\\n+\\n+**macOS / Linux:**\\n+\\n+```bash\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything/reasonix-skill\\n+./scripts/install.sh\\n+```\\n+\\n+**Windows (PowerShell):**\\n+\\n+```powershell\\n+git clone https://github.com/HKUDS/CLI-Anything.git\\n+cd CLI-Anything\\\\reasonix-skill\\n+.\\\\scripts\\\\install.ps1\\n+```\\n+\\n+Both scripts copy the skill to Reasonix's global skill directory at `~/.reasonix/skills/cli-anything`.\\n+\\n+## Configuration Note\\n+\\n+A full CLI-Anything build (architecture analysis, 10+ file generation, installation, and multiple test runs) typically requires 25–40 tool-call rounds. Reasonix's subagent step budget is derived from the `agent.max_steps` setting in `reasonix.toml`:\\n+\\n+- The default `max_steps = 0` means unlimited, which is recommended for this workflow.\\n+- If you have set `max_steps` to a finite value, the subagent receives half that budget (minimum 5), which may cause a build to be truncated before completion.\\n+\\n+To ensure builds complete successfully, set `agent.max_steps = 0` in your `reasonix.toml`, or use a sufficiently high value such as 64 or more.\\n+\\n+## Usage\\n+\\n+After installation, use slash invocation to inline the skill into the parent Reasonix loop:\\n+\\n+```\\n+/cli-anything https://github.com/GNOME/gimp\\n+```\\n+\\n+Use `run_skill` when you want isolated subagent execution. The same isolation applies when Reasonix invokes the skill through its dedicated subagent path:\\n+\\n+```\\n+run_skill({ name: \\\"cli-anything\\\", arguments: \\\"/path/to/software\\\" })\\n+```\\n+\\n+### What It Does\\n+\\n+The skill follows the CLI-Anything 7-phase methodology:\\n+\\n+1. **Codebase Analysis** — Surveys the target software's architecture, data model, and API surface\\n+2. **CLI Architecture Design** — Designs command groups, state model, and output formats\\n+3. **Implementation** — Generates a Click-based Python CLI with REPL, JSON output, and session state\\n+4. **Test Planning** — Creates TEST.md with comprehensive test plan\\n+5. **Test Implementation** — Writes unit tests and E2E tests with real backend invocation\\n+6. **Test Documentation** — Runs all tests and documents results\\n+7. **PyPI Packaging** — Creates setup.py and verifies `pip install -e .`\\n+\\n+### Example\\n+\\n+```bash\\n+# Build a CLI for GIMP from local source\\n+/cli-anything /home/user/gimp\\n+\\n+# Build from a GitHub repo\\n+/cli-anything https://github.com/blender/blender\\n+\\n+# Refine an existing harness\\n+/cli-anything /home/user/gimp \\\"Refine the existing harness for batch processing and Script-Fu filters\\\"\\n+```\\n+\\n+## Reasonix Tool Mapping\\n+\\n+| CLI-Anything Need | Reasonix Tool |\\n+|-------------------|---------------|\\n+| Shell execution | `bash` |\\n+| File generation | `write_file` |\\n+| Code editing | `edit_file` / `multi_edit` |\\n+| Source reading | `read_file` |\\n+| Codebase search | `grep` / `glob` / `ls` |\\n+| Architecture analysis | `mcp__codegraph__search` / `mcp__codegraph__context` when CodeGraph is enabled |\\n+| Documentation fetch | `web_fetch` |\\n+\\n+## File Structure\\n+\\n+```\\n+reasonix-skill/\\n+├── SKILL.md # Main skill document (methodology + tool bindings)\\n+├── README.md # This file\\n+├── agents/\\n+│ └── reasonix.yaml # Agent interface metadata\\n+└── scripts/\\n+ ├── install.sh # macOS/Linux installer\\n+ └── install.ps1 # Windows installer\\n+```\\n+\\n+## How It Compares to Other Agent Adapters\\n+\\n+| Feature | Claude Code | Codex | Hermes | **Reasonix** |\\n+|---------|------------|-------|--------|-------------|\\n+| Skill format | `.claude-plugin/` | `SKILL.md` + YAML | `SKILL.md` + YAML | `SKILL.md` + YAML |\\n+| Shell | `bash` | `terminal` | `terminal` | `bash` |\\n+| File ops | native | `execute_code` | `execute_code` / `write_file` | `write_file` / `edit_file` / `multi_edit` |\\n+| Code analysis | file reads | file reads | file reads | Optional `mcp__codegraph__search` / `mcp__codegraph__context` symbol graph |\\n+| Install method | `/plugin install` | `install.sh` → `$CODEX_HOME/skills/` | `install.sh` → `$HERMES_HOME/skills/` | `install.sh` → `~/.reasonix/skills/` |\\n+\\n+## Contributing\\n+\\n+This adapter follows the same contribution pattern as the Codex and Hermes adapters. See [CONTRIBUTING.md](../CONTRIBUTING.md) in the CLI-Anything repository.\\n+\\n+## License\\n+\\n+Apache License 2.0 — same as CLI-Anything.\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4832,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":345,"string":"345"},"task_type":{"kind":"string","value":"issue_to_patch"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"feat: add Web Yu-pri CLI harness"},"pr_body":{"kind":"string","value":"## Description\n\nAdds an in-repo CLI-Anything harness for Japan Post Web Yu-pri browser workflows.\n\nThe harness uses Playwright to drive the real Web Yu-pri UI with a persistent browser profile. It supports login-page opening, status inspection, screenshots, item-file planning, and contents-form filling. The first version intentionally stops before final shipment confirmation and does not store Japan Post credentials.\n\n## Type of Change\n\n- [x] **New Software CLI (in-repo)** - adds a CLI harness inside this monorepo\n\n---\n\n### For New Software CLIs (in-repo)\n\n- [x] `<SOFTWARE>.md` SOP document exists at `<software>/agent-harness/<SOFTWARE>.md`\n- [x] Canonical `SKILL.md` exists at `skills/cli-anything-<software>/SKILL.md`\n- [x] Packaged compatibility `SKILL.md` exists at `cli_anything/<software>/skills/SKILL.md`\n- [x] Unit tests at `cli_anything/<software>/tests/test_core.py` are present and pass without backend\n- [x] E2E tests at `cli_anything/<software>/tests/test_full_e2e.py` are present\n- [x] `README.md` includes the new software (with link to harness directory)\n- [x] `registry.json` includes an entry with `source_url: null`\n- [x] `repl_skin.py` in `utils/` is an unmodified copy from the plugin\n\n### General Checklist\n\n- [x] Code follows existing patterns and conventions\n- [x] `--json` flag is supported on new commands\n- [x] Commit messages follow the conventional format (`feat:`)\n- [x] I have tested my changes locally\n\n## Test Results\n\n```text\npython -m pytest cli_anything/web_yu_pri/tests -v\n13 passed, 1 skipped\n\npython .github/scripts/validate_root_skills.py\nRoot skills validation passed.\n\npython -m json.tool registry.json\npassed\n\npython -m build\npassed\n\npython -m twine check dist/*\nPASSED\n```\n\nThe skipped live test is gated by `WEB_YU_PRI_LIVE_E2E=1` because it requires a real Japan Post account and logged-in browser profile."},"base_sha":{"kind":"string","value":"f23e051a053dfe34737f3d542f9fb3952d23922d"},"head_sha":{"kind":"string","value":"76ddd417358ce0ec35ab2ef06dee090442061e77"},"gold_diff":{"kind":"string","value":"diff --git a/.gitignore b/.gitignore\nindex 618c70154..0d858f379 100644\n--- a/.gitignore\n+++ b/.gitignore\n@@ -70,6 +70,7 @@\n !/minimax/\n !/ollama/\n !/browser/\n+!/web-yu-pri/\n !/seaclip/\n !/pm2/\n !/chromadb/\n@@ -143,6 +144,8 @@\n /ollama/.*\n /browser/*\n /browser/.*\n+/web-yu-pri/*\n+/web-yu-pri/.*\n /seaclip/*\n /seaclip/.*\n /pm2/*\n@@ -229,6 +232,7 @@\n !/minimax/agent-harness/\n !/ollama/agent-harness/\n !/browser/agent-harness/\n+!/web-yu-pri/agent-harness/\n !/seaclip/agent-harness/\n !/pm2/agent-harness/\n !/chromadb/agent-harness/\ndiff --git a/README.md b/README.md\nindex 9672f4ab2..d9e89fd81 100644\n--- a/README.md\n+++ b/README.md\n@@ -993,6 +993,13 @@ Each application received complete, production-ready CLI interfaces — not demo\n <td align=\"center\">✅ <a href=\"browser/agent-harness/\">New</a></td>\n </tr>\n <tr>\n+<td align=\"center\"><strong><a href=\"web-yu-pri/agent-harness/\">Web Yu-pri</a></strong></td>\n+<td>Japan Post Shipping Labels</td>\n+<td><code>cli-anything-web-yu-pri</code></td>\n+<td>Playwright + Web Yu-pri forms</td>\n+<td align=\"center\">✅ <a href=\"web-yu-pri/agent-harness/\">New</a></td>\n+</tr>\n+<tr>\n <td align=\"center\"><strong>📄 LibreOffice</strong></td>\n <td>Office Suite (Writer, Calc, Impress)</td>\n <td><code>cli-anything-libreoffice</code></td>\n@@ -1345,6 +1352,7 @@ cli-anything/\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI (202 tests)\n ├── 🎵 audacity/agent-harness/ # Audacity CLI (161 tests)\n ├── 🌐 browser/agent-harness/ # Browser CLI (DOMShell MCP, new)\n+├── 🌐 web-yu-pri/agent-harness/ # Japan Post Web Yu-pri CLI (new)\n ├── 📄 libreoffice/agent-harness/ # LibreOffice CLI (158 tests)\n ├── 📧 mailchimp/agent-harness/ # Mailchimp Marketing API CLI (303 commands, 36 unit tests)\n ├── 📚 zotero/agent-harness/ # Zotero CLI (new, write import support)\ndiff --git a/registry.json b/registry.json\nindex 851cbafa1..f9fcaabc6 100644\n--- a/registry.json\n+++ b/registry.json\n@@ -138,6 +138,25 @@\n }\n ]\n },\n+ {\n+ \"name\": \"web-yu-pri\",\n+ \"display_name\": \"Web Yu-pri\",\n+ \"version\": \"0.1.0\",\n+ \"description\": \"Japan Post Web Yu-pri browser workflow automation for login, inspection, screenshots, dry-run planning, and contents-form filling\",\n+ \"requires\": \"Japan Post Web Yu-pri account, Playwright, Microsoft Edge/Chrome or Playwright Chromium\",\n+ \"homepage\": \"https://mgr.post.japanpost.jp/C30P01Action.do\",\n+ \"source_url\": null,\n+ \"install_cmd\": \"pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\",\n+ \"entry_point\": \"cli-anything-web-yu-pri\",\n+ \"skill_md\": \"skills/cli-anything-web-yu-pri/SKILL.md\",\n+ \"category\": \"web\",\n+ \"contributors\": [\n+ {\n+ \"name\": \"shinpei710\",\n+ \"url\": \"https://github.com/shinpei710\"\n+ }\n+ ]\n+ },\n {\n \"name\": \"comfyui\",\n \"display_name\": \"ComfyUI\",\ndiff --git a/skills/cli-anything-web-yu-pri/SKILL.md b/skills/cli-anything-web-yu-pri/SKILL.md\nnew file mode 100644\nindex 000000000..af40f54be\n--- /dev/null\n+++ b/skills/cli-anything-web-yu-pri/SKILL.md\n@@ -0,0 +1,85 @@\n+---\n+name: \"cli-anything-web-yu-pri\"\n+description: Use Japan Post Web Yu-pri from a CLI by driving the real browser UI for login, inspection, screenshots, dry-run planning, and contents-form filling.\n+---\n+\n+# Web Yu-pri CLI\n+\n+Use this skill when a task involves Japan Post Web Yu-pri label entry at\n+`https://mgr.post.japanpost.jp/C30P01Action.do`, especially repetitive contents\n+line entry.\n+\n+## Install\n+\n+```bash\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\n+```\n+\n+If no browser is found:\n+\n+```bash\n+python -m playwright install chromium\n+```\n+\n+## Safety Rules\n+\n+- Do not put Japan Post credentials in commands, files, logs, or prompts.\n+- Use `open-login` so the user can log in manually in the persistent profile.\n+- Run `contents fill ... --dry-run --json` before live form filling.\n+- This CLI does not click final shipment confirmation or purchase buttons.\n+- Keep item lines separate when the source data has separate award/category\n+ lines, while preserving the requested declared total.\n+\n+## Common Commands\n+\n+```bash\n+cli-anything-web-yu-pri --json doctor\n+cli-anything-web-yu-pri open-login\n+cli-anything-web-yu-pri --json status --url https://mgr.post.japanpost.jp/M060800.do\n+cli-anything-web-yu-pri --json plan items.json\n+cli-anything-web-yu-pri --json contents fill items.json --dry-run\n+cli-anything-web-yu-pri --json contents fill items.json --total-value 17000\n+```\n+\n+## Items File\n+\n+JSON:\n+\n+```json\n+{\n+ \"items\": [\n+ {\"description\": \"Award plaque\", \"value\": 8000, \"quantity\": 1, \"country\": \"KR\"},\n+ {\"description\": \"Certificate\", \"value\": 9000, \"quantity\": 1, \"country\": \"KR\"}\n+ ]\n+}\n+```\n+\n+CSV headers can use these aliases:\n+\n+- description: `description`, `desc`, `content`, `contents`, `item`, `name`, `pkg`\n+- value: `value`, `declared_value`, `cost`, `price`, `amount`, `yen`, `jpy`\n+- quantity: `quantity`, `qty`, `num`, `count`\n+- country: `country`, `country_code`, `country_of_origin`, `origin`, `couCd`, `cou_cd`\n+- HS code: `hs_code`, `hs`, `hscode`, `hsCode`\n+\n+By default, `value` is treated as the line declared value. Use `--value-mode unit`\n+when value should be multiplied by quantity.\n+\n+## Selector Diagnostics\n+\n+```bash\n+cli-anything-web-yu-pri --json selectors\n+cli-anything-web-yu-pri snapshot --url https://mgr.post.japanpost.jp/M060800.do -o page.png --html-output page.html\n+```\n+\n+Known contents-page controls:\n+\n+- `#M060800_itemBean_pkg`\n+- `#M060800_itemBean_cost_value`\n+- `#M060800_itemBean_num_value`\n+- `#M060800_itemBean_couCd`\n+- `#M060800_itemBean_hsCode`\n+- `#M060800_shippingBean_pkgType`\n+- `#M060800_shippingBean_pkgTotalPrice_value`\n+- `#M060800_ShippingBean_danger`\n+- `submitCommand('itemAdd2')`\ndiff --git a/web-yu-pri/agent-harness/README.md b/web-yu-pri/agent-harness/README.md\nnew file mode 100644\nindex 000000000..e22891683\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/README.md\n@@ -0,0 +1,71 @@\n+# cli-anything-web-yu-pri\n+\n+CLI harness for Japan Post Web Yu-pri label workflows.\n+\n+This CLI drives the real Web Yu-pri browser UI through Playwright. It uses a\n+persistent local browser profile so you can log in manually once, then run\n+structured commands for repetitive form entry. It does not store passwords and\n+does not click final shipment confirmation buttons.\n+\n+## Install\n+\n+```bash\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\n+```\n+\n+If Playwright cannot find a browser, install Microsoft Edge or Chrome, or run:\n+\n+```bash\n+python -m playwright install chromium\n+```\n+\n+## Quick Start\n+\n+```bash\n+cli-anything-web-yu-pri doctor\n+cli-anything-web-yu-pri open-login\n+cli-anything-web-yu-pri plan items.json --json\n+cli-anything-web-yu-pri contents fill items.json --dry-run --json\n+cli-anything-web-yu-pri contents fill items.json --json\n+```\n+\n+## Items File\n+\n+JSON:\n+\n+```json\n+{\n+ \"items\": [\n+ {\"description\": \"Award plaque\", \"value\": 8000, \"quantity\": 1, \"country\": \"KR\"},\n+ {\"description\": \"Certificate\", \"value\": 9000, \"quantity\": 1, \"country\": \"KR\"}\n+ ]\n+}\n+```\n+\n+CSV:\n+\n+```csv\n+description,value,quantity,country,hs_code\n+Award plaque,8000,1,KR,\n+Certificate,9000,1,KR,\n+```\n+\n+`value` is a line value by default. Add `--value-mode unit` when value should be\n+multiplied by quantity.\n+\n+## Commands\n+\n+| Command | Description |\n+| --- | --- |\n+| `doctor` | Check local runtime and profile paths |\n+| `selectors` | Print the known Web Yu-pri selector map |\n+| `plan <items-file>` | Validate JSON/CSV/TSV items and compute totals |\n+| `open-login` | Open the login/start URL in the persistent profile |\n+| `status` | Inspect title, URL, and selector presence |\n+| `snapshot -o page.png` | Capture screenshot and optional HTML |\n+| `contents fill <items-file>` | Fill contents rows and declared total |\n+\n+## Safety\n+\n+`contents fill` stops after filling contents and totals. It returns a `safety`\n+object in JSON output with `final_submit_clicked: false`.\ndiff --git a/web-yu-pri/agent-harness/WEB_YU_PRI.md b/web-yu-pri/agent-harness/WEB_YU_PRI.md\nnew file mode 100644\nindex 000000000..3a999f840\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/WEB_YU_PRI.md\n@@ -0,0 +1,68 @@\n+# Web Yu-pri Harness SOP\n+\n+## Purpose\n+\n+This harness turns Japan Post's Web Yu-pri browser workflow into an\n+agent-friendly CLI. Web Yu-pri is a logged-in web application, so the CLI drives\n+the real browser UI through Playwright instead of reimplementing Japan Post\n+business logic.\n+\n+## Backend Surface\n+\n+- Official start URL: `https://mgr.post.japanpost.jp/C30P01Action.do`\n+- Known contents form URL: `https://mgr.post.japanpost.jp/M060800.do`\n+- Browser engine: Playwright Chromium with a persistent user profile\n+- Credentials: never accepted or stored by the CLI; users log in manually in the\n+ browser profile\n+\n+## Safety Model\n+\n+The first version automates repetitive data entry only. It fills item contents,\n+declared value totals, optional package type, and dangerous-goods flags, but it\n+does not click the final shipment confirmation/submit button. Agents should use\n+`--dry-run` before touching the real page, then inspect `verification` in JSON\n+output after a live fill.\n+\n+## Commands\n+\n+- `doctor` checks Playwright availability and profile paths.\n+- `selectors` prints the known selector map for page diagnostics.\n+- `plan <items-file>` validates JSON/CSV/TSV item files and computes totals.\n+- `open-login` opens the Web Yu-pri start URL in the persistent profile.\n+- `status` opens a URL and reports current title, URL, and selector presence.\n+- `snapshot` captures a screenshot and optional HTML dump.\n+- `contents fill <items-file>` fills item rows on the contents form.\n+\n+## Input Model\n+\n+The CLI accepts JSON, CSV, or TSV files. Each row supports the following aliases:\n+\n+- description: `description`, `desc`, `content`, `contents`, `item`, `name`, `pkg`\n+- value: `value`, `declared_value`, `cost`, `price`, `amount`, `yen`, `jpy`\n+- quantity: `quantity`, `qty`, `num`, `count`\n+- country: `country`, `country_code`, `country_of_origin`, `origin`, `couCd`, `cou_cd`\n+- HS code: `hs_code`, `hs`, `hscode`, `hsCode`\n+\n+By default, `value` is treated as the line declared value. Use\n+`--value-mode unit` when `value` is a unit value that should be multiplied by\n+quantity.\n+\n+## Known Web Yu-pri Selectors\n+\n+- Item description: `#M060800_itemBean_pkg`\n+- Item value: `#M060800_itemBean_cost_value`\n+- Item quantity: `#M060800_itemBean_num_value`\n+- Country of origin: `#M060800_itemBean_couCd`\n+- HS code: `#M060800_itemBean_hsCode`\n+- Package type: `#M060800_shippingBean_pkgType`\n+- Total declared value: `#M060800_shippingBean_pkgTotalPrice_value`\n+- Dangerous-goods flag: `#M060800_ShippingBean_danger`\n+- Add item command: `submitCommand('itemAdd2')`\n+\n+## Test Strategy\n+\n+Unit tests cover item parsing, total computation, selector publication, and dry\n+run output without launching a browser. The E2E test file includes a real CLI\n+dry-run workflow and an optional live test gated by `WEB_YU_PRI_LIVE_E2E=1`,\n+because live execution requires a Japan Post account and a real logged-in\n+session.\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/README.md b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/README.md\nnew file mode 100644\nindex 000000000..e22891683\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/README.md\n@@ -0,0 +1,71 @@\n+# cli-anything-web-yu-pri\n+\n+CLI harness for Japan Post Web Yu-pri label workflows.\n+\n+This CLI drives the real Web Yu-pri browser UI through Playwright. It uses a\n+persistent local browser profile so you can log in manually once, then run\n+structured commands for repetitive form entry. It does not store passwords and\n+does not click final shipment confirmation buttons.\n+\n+## Install\n+\n+```bash\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\n+```\n+\n+If Playwright cannot find a browser, install Microsoft Edge or Chrome, or run:\n+\n+```bash\n+python -m playwright install chromium\n+```\n+\n+## Quick Start\n+\n+```bash\n+cli-anything-web-yu-pri doctor\n+cli-anything-web-yu-pri open-login\n+cli-anything-web-yu-pri plan items.json --json\n+cli-anything-web-yu-pri contents fill items.json --dry-run --json\n+cli-anything-web-yu-pri contents fill items.json --json\n+```\n+\n+## Items File\n+\n+JSON:\n+\n+```json\n+{\n+ \"items\": [\n+ {\"description\": \"Award plaque\", \"value\": 8000, \"quantity\": 1, \"country\": \"KR\"},\n+ {\"description\": \"Certificate\", \"value\": 9000, \"quantity\": 1, \"country\": \"KR\"}\n+ ]\n+}\n+```\n+\n+CSV:\n+\n+```csv\n+description,value,quantity,country,hs_code\n+Award plaque,8000,1,KR,\n+Certificate,9000,1,KR,\n+```\n+\n+`value` is a line value by default. Add `--value-mode unit` when value should be\n+multiplied by quantity.\n+\n+## Commands\n+\n+| Command | Description |\n+| --- | --- |\n+| `doctor` | Check local runtime and profile paths |\n+| `selectors` | Print the known Web Yu-pri selector map |\n+| `plan <items-file>` | Validate JSON/CSV/TSV items and compute totals |\n+| `open-login` | Open the login/start URL in the persistent profile |\n+| `status` | Inspect title, URL, and selector presence |\n+| `snapshot -o page.png` | Capture screenshot and optional HTML |\n+| `contents fill <items-file>` | Fill contents rows and declared total |\n+\n+## Safety\n+\n+`contents fill` stops after filling contents and totals. It returns a `safety`\n+object in JSON output with `final_submit_clicked: false`.\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/__init__.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/__init__.py\nnew file mode 100644\nindex 000000000..5672e0bec\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/__init__.py\n@@ -0,0 +1,3 @@\n+\"\"\"CLI-Anything harness for Japan Post Web Yu-pri.\"\"\"\n+\n+__version__ = \"0.1.0\"\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/__main__.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/__main__.py\nnew file mode 100644\nindex 000000000..7e0c00594\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/__main__.py\n@@ -0,0 +1,5 @@\n+from .web_yu_pri_cli import main\n+\n+\n+if __name__ == \"__main__\":\n+ main()\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/__init__.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/__init__.py\nnew file mode 100644\nindex 000000000..70783e70c\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/__init__.py\n@@ -0,0 +1,1 @@\n+\"\"\"Core helpers for Web Yu-pri automation.\"\"\"\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\nnew file mode 100644\nindex 000000000..148ca168c\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\n@@ -0,0 +1,383 @@\n+\"\"\"Playwright backend for the real Web Yu-pri web application.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import time\n+from contextlib import contextmanager\n+from pathlib import Path\n+from typing import Any, Iterator\n+\n+from .items import ItemLine, build_contents_plan\n+\n+LOGIN_URL = \"https://mgr.post.japanpost.jp/C30P01Action.do\"\n+CONTENTS_URL = \"https://mgr.post.japanpost.jp/M060800.do\"\n+\n+SELECTORS = {\n+ \"item_description\": \"#M060800_itemBean_pkg\",\n+ \"item_value\": \"#M060800_itemBean_cost_value\",\n+ \"item_quantity\": \"#M060800_itemBean_num_value\",\n+ \"item_country\": \"#M060800_itemBean_couCd\",\n+ \"item_hs_code\": \"#M060800_itemBean_hsCode\",\n+ \"package_type\": \"#M060800_shippingBean_pkgType\",\n+ \"total_value\": \"#M060800_shippingBean_pkgTotalPrice_value\",\n+ \"danger\": \"#M060800_ShippingBean_danger\",\n+}\n+\n+ADD_ITEM_COMMAND = \"itemAdd2\"\n+\n+\n+def default_profile_dir() -> Path:\n+ return Path.home() / \".cli-anything-web-yu-pri\" / \"profile\"\n+\n+\n+def selector_report() -> dict[str, Any]:\n+ return {\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ }\n+\n+\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\n+ result: dict[str, Any] = {\n+ \"profile_dir\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"playwright_available\": False,\n+ \"notes\": [],\n+ }\n+ try:\n+ import playwright # noqa: F401\n+\n+ result[\"playwright_available\"] = True\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\n+ result[\"notes\"].append(f\"playwright import failed: {exc}\")\n+ return result\n+\n+\n+@contextmanager\n+def browser_session(\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> Iterator[tuple[Any, Any]]:\n+ \"\"\"Launch a persistent browser context and yield (page, context).\"\"\"\n+\n+ try:\n+ from playwright.sync_api import Error as PlaywrightError\n+ from playwright.sync_api import sync_playwright\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\n+ raise RuntimeError(\n+ \"playwright is required. Install with: pip install cli-anything-web-yu-pri\"\n+ ) from exc\n+\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\n+\n+ playwright = sync_playwright().start()\n+ context = None\n+ errors: list[str] = []\n+ channels = [browser_channel] if browser_channel else [\"msedge\", \"chrome\", None]\n+ try:\n+ for channel in channels:\n+ try:\n+ kwargs: dict[str, Any] = {\n+ \"headless\": headless,\n+ \"args\": [\"--disable-blink-features=AutomationControlled\"],\n+ }\n+ if channel:\n+ kwargs[\"channel\"] = channel\n+ context = playwright.chromium.launch_persistent_context(\n+ str(user_data_dir),\n+ **kwargs,\n+ )\n+ break\n+ except PlaywrightError as exc:\n+ label = channel or \"bundled-chromium\"\n+ errors.append(f\"{label}: {exc}\")\n+ if context is None:\n+ detail = \" | \".join(errors) if errors else \"no browser channels attempted\"\n+ raise RuntimeError(f\"could not launch Chromium/Edge browser: {detail}\")\n+\n+ page = context.pages[0] if context.pages else context.new_page()\n+ yield page, context\n+ finally:\n+ if context is not None:\n+ context.close()\n+ playwright.stop()\n+\n+\n+def open_login(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def inspect_url(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def capture_snapshot(\n+ url: str,\n+ output: str | Path,\n+ html_output: str | Path | None = None,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ output_path = Path(output).expanduser().resolve()\n+ output_path.parent.mkdir(parents=True, exist_ok=True)\n+ html_path = Path(html_output).expanduser().resolve() if html_output else None\n+ if html_path:\n+ html_path.parent.mkdir(parents=True, exist_ok=True)\n+\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ page.screenshot(path=str(output_path), full_page=True)\n+ if html_path:\n+ html_path.write_text(page.content(), encoding=\"utf-8\")\n+ info = inspect_page(page)\n+ info[\"screenshot\"] = str(output_path)\n+ if html_path:\n+ info[\"html\"] = str(html_path)\n+ return info\n+\n+\n+def inspect_page(page: Any) -> dict[str, Any]:\n+ \"\"\"Return cheap, JSON-safe page facts.\"\"\"\n+\n+ selector_presence = {\n+ name: page.locator(selector).count() > 0 for name, selector in SELECTORS.items()\n+ }\n+ return {\n+ \"url\": page.url,\n+ \"title\": page.title(),\n+ \"has_contents_form\": all(\n+ selector_presence[key]\n+ for key in (\"item_description\", \"item_value\", \"item_quantity\", \"total_value\")\n+ ),\n+ \"selectors\": selector_presence,\n+ }\n+\n+\n+def fill_contents(\n+ items: list[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+ url: str = CONTENTS_URL,\n+ profile_dir: str | Path | None = None,\n+ package_type: str | None = None,\n+ danger: bool | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+ delay_ms: int = 500,\n+) -> dict[str, Any]:\n+ \"\"\"Fill the known Web Yu-pri contents form and add each item line.\"\"\"\n+\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ _require_selector(page, SELECTORS[\"item_description\"])\n+\n+ if package_type:\n+ _set_value(page, SELECTORS[\"package_type\"], package_type)\n+ if danger is not None:\n+ _set_boolean(page, SELECTORS[\"danger\"], danger)\n+\n+ added: list[dict[str, Any]] = []\n+ for item in items:\n+ _fill_item(page, item)\n+ before = _body_fingerprint(page)\n+ _run_submit_command(page, ADD_ITEM_COMMAND)\n+ _wait_after_submit(page, before=before, delay_ms=delay_ms)\n+ added.append(\n+ {\n+ \"description\": item.description,\n+ \"value\": item.value,\n+ \"quantity\": item.quantity,\n+ \"country\": item.country,\n+ \"hs_code\": item.hs_code,\n+ }\n+ )\n+\n+ _set_value(page, SELECTORS[\"total_value\"], str(plan[\"declared_total\"]))\n+ info = inspect_page(page)\n+ verification = _verify_descriptions(page, [item.description for item in items])\n+ return {\n+ \"status\": \"filled\",\n+ \"plan\": plan,\n+ \"added\": added,\n+ \"page\": info,\n+ \"verification\": verification,\n+ \"safety\": {\n+ \"final_submit_clicked\": False,\n+ \"message\": \"Contents were filled only; final shipment confirmation is not clicked.\",\n+ },\n+ }\n+\n+\n+def build_dry_run(\n+ items: list[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+ package_type: str | None = None,\n+ danger: bool | None = None,\n+) -> dict[str, Any]:\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ return {\n+ \"dry_run\": True,\n+ \"plan\": plan,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ \"package_type\": package_type,\n+ \"danger\": danger,\n+ \"safety\": {\n+ \"browser_launched\": False,\n+ \"final_submit_clicked\": False,\n+ },\n+ }\n+\n+\n+def _fill_item(page: Any, item: ItemLine) -> None:\n+ _set_value(page, SELECTORS[\"item_description\"], item.description)\n+ _set_value(page, SELECTORS[\"item_value\"], str(item.value))\n+ _set_value(page, SELECTORS[\"item_quantity\"], str(item.quantity))\n+ if item.country:\n+ _set_value(page, SELECTORS[\"item_country\"], item.country)\n+ if item.hs_code:\n+ _set_value(page, SELECTORS[\"item_hs_code\"], item.hs_code)\n+\n+\n+def _require_selector(page: Any, selector: str, timeout_ms: int = 15_000) -> None:\n+ try:\n+ page.wait_for_selector(selector, timeout=timeout_ms)\n+ except Exception as exc:\n+ info = {\n+ \"url\": page.url,\n+ \"title\": page.title(),\n+ \"expected_selector\": selector,\n+ }\n+ raise RuntimeError(\n+ \"Web Yu-pri contents form was not found. \"\n+ f\"Page facts: {json.dumps(info, ensure_ascii=False)}\"\n+ ) from exc\n+\n+\n+def _set_value(page: Any, selector: str, value: str) -> None:\n+ locator = page.locator(selector)\n+ if locator.count() == 0:\n+ return\n+ try:\n+ tag_name = locator.first.evaluate(\"el => el.tagName.toLowerCase()\")\n+ if tag_name == \"select\":\n+ locator.first.select_option(value)\n+ else:\n+ locator.first.fill(str(value))\n+ except Exception:\n+ locator.first.evaluate(\n+ \"\"\"(el, value) => {\n+ el.value = value;\n+ el.dispatchEvent(new Event('input', {bubbles: true}));\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\n+ }\"\"\",\n+ str(value),\n+ )\n+\n+\n+def _set_boolean(page: Any, selector: str, value: bool) -> None:\n+ locator = page.locator(selector)\n+ if locator.count() == 0:\n+ return\n+ try:\n+ input_type = locator.first.evaluate(\"el => (el.type || '').toLowerCase()\")\n+ if input_type in {\"checkbox\", \"radio\"}:\n+ locator.first.set_checked(value)\n+ return\n+ except Exception:\n+ pass\n+ locator.first.evaluate(\n+ \"\"\"(el, value) => {\n+ el.checked = Boolean(value);\n+ el.value = value ? '1' : '';\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\n+ }\"\"\",\n+ value,\n+ )\n+\n+\n+def _run_submit_command(page: Any, command: str) -> None:\n+ page.evaluate(\n+ \"\"\"command => {\n+ if (typeof window.submitCommand === 'function') {\n+ window.submitCommand(command);\n+ return;\n+ }\n+ throw new Error('submitCommand is not available on this page');\n+ }\"\"\",\n+ command,\n+ )\n+\n+\n+def _wait_after_submit(page: Any, before: str, delay_ms: int) -> None:\n+ try:\n+ page.wait_for_load_state(\"domcontentloaded\", timeout=10_000)\n+ except Exception:\n+ pass\n+ deadline = time.time() + 10\n+ while time.time() < deadline:\n+ time.sleep(max(delay_ms, 100) / 1000)\n+ if _body_fingerprint(page) != before:\n+ return\n+\n+\n+def _body_fingerprint(page: Any) -> str:\n+ try:\n+ return page.evaluate(\n+ \"\"\"() => {\n+ const text = document.body ? document.body.innerText : '';\n+ const inputs = Array.from(document.querySelectorAll('input,select,textarea'))\n+ .slice(0, 200)\n+ .map(el => `${el.id || el.name || ''}:${el.value || ''}`)\n+ .join('|');\n+ return `${location.href}|${text.length}|${inputs.length}|${inputs}`;\n+ }\"\"\"\n+ )\n+ except Exception:\n+ return f\"{page.url}:{time.time()}\"\n+\n+\n+def _verify_descriptions(page: Any, descriptions: list[str]) -> dict[str, Any]:\n+ body_text = page.evaluate(\"() => document.body ? document.body.innerText : ''\")\n+ found = [description for description in descriptions if description in body_text]\n+ missing = [description for description in descriptions if description not in body_text]\n+ return {\n+ \"descriptions_found\": found,\n+ \"descriptions_missing\": missing,\n+ \"all_found\": not missing,\n+ }\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/items.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/items.py\nnew file mode 100644\nindex 000000000..53bbd1afb\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/items.py\n@@ -0,0 +1,202 @@\n+\"\"\"Input normalization for Web Yu-pri contents lines.\"\"\"\n+\n+from __future__ import annotations\n+\n+import csv\n+import json\n+import re\n+from dataclasses import asdict, dataclass\n+from pathlib import Path\n+from typing import Any, Iterable\n+\n+\n+DESCRIPTION_KEYS = (\"description\", \"desc\", \"content\", \"contents\", \"item\", \"name\", \"pkg\")\n+VALUE_KEYS = (\"value\", \"declared_value\", \"cost\", \"price\", \"amount\", \"yen\", \"jpy\")\n+QUANTITY_KEYS = (\"quantity\", \"qty\", \"num\", \"count\")\n+COUNTRY_KEYS = (\"country\", \"country_code\", \"country_of_origin\", \"origin\", \"couCd\", \"cou_cd\")\n+HS_KEYS = (\"hs_code\", \"hs\", \"hscode\", \"hsCode\")\n+_MISSING = object()\n+\n+\n+@dataclass(frozen=True)\n+class ItemLine:\n+ \"\"\"One declared contents line for a Web Yu-pri shipment.\"\"\"\n+\n+ description: str\n+ value: int\n+ quantity: int = 1\n+ country: str | None = None\n+ hs_code: str | None = None\n+\n+ def to_dict(self, value_mode: str = \"line\") -> dict[str, Any]:\n+ line_total = self.line_total(value_mode=value_mode)\n+ data = asdict(self)\n+ data[\"line_total\"] = line_total\n+ data[\"value_mode\"] = value_mode\n+ return data\n+\n+ def line_total(self, value_mode: str = \"line\") -> int:\n+ if value_mode == \"unit\":\n+ return self.value * self.quantity\n+ if value_mode == \"line\":\n+ return self.value\n+ raise ValueError(\"value_mode must be 'line' or 'unit'\")\n+\n+\n+def load_items(path: str | Path, default_country: str | None = None) -> list[ItemLine]:\n+ \"\"\"Load contents lines from JSON, CSV, or TSV.\"\"\"\n+\n+ input_path = Path(path)\n+ suffix = input_path.suffix.lower()\n+ if suffix == \".json\":\n+ return _load_json(input_path, default_country=default_country)\n+ if suffix in {\".csv\", \".tsv\"}:\n+ delimiter = \"\\t\" if suffix == \".tsv\" else \",\"\n+ return _load_delimited(input_path, delimiter=delimiter, default_country=default_country)\n+ raise ValueError(\"items file must be .json, .csv, or .tsv\")\n+\n+\n+def build_contents_plan(\n+ items: Iterable[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+) -> dict[str, Any]:\n+ \"\"\"Build a deterministic fill plan for the contents form.\"\"\"\n+\n+ if value_mode not in {\"line\", \"unit\"}:\n+ raise ValueError(\"value_mode must be 'line' or 'unit'\")\n+\n+ item_list = list(items)\n+ if not item_list:\n+ raise ValueError(\"at least one item line is required\")\n+\n+ computed_total = sum(item.line_total(value_mode=value_mode) for item in item_list)\n+ declared_total = computed_total if total_value is None else _coerce_int(\n+ total_value, \"total_value\", minimum=0\n+ )\n+\n+ warnings: list[str] = []\n+ if declared_total != computed_total:\n+ warnings.append(\n+ f\"declared total {declared_total} does not match computed item total {computed_total}\"\n+ )\n+\n+ return {\n+ \"item_count\": len(item_list),\n+ \"computed_total\": computed_total,\n+ \"declared_total\": declared_total,\n+ \"total_matches\": declared_total == computed_total,\n+ \"value_mode\": value_mode,\n+ \"warnings\": warnings,\n+ \"items\": [item.to_dict(value_mode=value_mode) for item in item_list],\n+ }\n+\n+\n+def parse_item_mapping(row: dict[str, Any], default_country: str | None = None) -> ItemLine:\n+ \"\"\"Normalize one user-provided mapping into an ItemLine.\"\"\"\n+\n+ description = str(_pick(row, DESCRIPTION_KEYS, \"description\")).strip()\n+ if not description:\n+ raise ValueError(\"description cannot be blank\")\n+\n+ value = _coerce_int(_pick(row, VALUE_KEYS, \"value\"), \"value\", minimum=0)\n+ quantity = _coerce_int(_pick(row, QUANTITY_KEYS, \"quantity\", default=1), \"quantity\", minimum=1)\n+\n+ raw_country = _pick(row, COUNTRY_KEYS, \"country\", default=default_country)\n+ country = _normalize_country(raw_country)\n+ hs_code = _normalize_hs_code(_pick(row, HS_KEYS, \"hs_code\", default=None))\n+\n+ return ItemLine(\n+ description=description,\n+ value=value,\n+ quantity=quantity,\n+ country=country,\n+ hs_code=hs_code,\n+ )\n+\n+\n+def _load_json(path: Path, default_country: str | None = None) -> list[ItemLine]:\n+ with path.open(\"r\", encoding=\"utf-8-sig\") as handle:\n+ payload = json.load(handle)\n+\n+ if isinstance(payload, dict):\n+ rows = payload.get(\"items\")\n+ if rows is None:\n+ raise ValueError(\"JSON object must contain an 'items' array\")\n+ else:\n+ rows = payload\n+\n+ if not isinstance(rows, list):\n+ raise ValueError(\"items payload must be a list\")\n+\n+ return [parse_item_mapping(_require_mapping(row), default_country=default_country) for row in rows]\n+\n+\n+def _load_delimited(\n+ path: Path,\n+ delimiter: str,\n+ default_country: str | None = None,\n+) -> list[ItemLine]:\n+ with path.open(\"r\", encoding=\"utf-8-sig\", newline=\"\") as handle:\n+ reader = csv.DictReader(handle, delimiter=delimiter)\n+ if not reader.fieldnames:\n+ raise ValueError(\"CSV/TSV file must include a header row\")\n+ return [\n+ parse_item_mapping(dict(row), default_country=default_country)\n+ for row in reader\n+ if any(str(value or \"\").strip() for value in row.values())\n+ ]\n+\n+\n+def _pick(\n+ row: dict[str, Any],\n+ keys: tuple[str, ...],\n+ label: str,\n+ default: Any = _MISSING,\n+) -> Any:\n+ for key in keys:\n+ if key in row and row[key] not in (None, \"\"):\n+ return row[key]\n+ if default is not _MISSING:\n+ return default\n+ raise ValueError(f\"missing required field: {label}\")\n+\n+\n+def _require_mapping(value: Any) -> dict[str, Any]:\n+ if not isinstance(value, dict):\n+ raise ValueError(\"each item must be an object/mapping\")\n+ return value\n+\n+\n+def _coerce_int(value: Any, label: str, minimum: int) -> int:\n+ if isinstance(value, bool):\n+ raise ValueError(f\"{label} must be an integer\")\n+ if isinstance(value, int):\n+ result = value\n+ else:\n+ text = str(value).strip()\n+ text = re.sub(r\"[,\\sJPYjpy¥￥円]\", \"\", text)\n+ if not re.fullmatch(r\"-?\\d+\", text):\n+ raise ValueError(f\"{label} must be an integer\")\n+ result = int(text)\n+ if result < minimum:\n+ raise ValueError(f\"{label} must be >= {minimum}\")\n+ return result\n+\n+\n+def _normalize_country(value: Any) -> str | None:\n+ if value in (None, \"\"):\n+ return None\n+ text = str(value).strip().upper()\n+ if not re.fullmatch(r\"[A-Z]{2}\", text):\n+ raise ValueError(\"country must be a two-letter ISO code, for example KR or US\")\n+ return text\n+\n+\n+def _normalize_hs_code(value: Any) -> str | None:\n+ if value in (None, \"\"):\n+ return None\n+ text = re.sub(r\"\\s+\", \"\", str(value).strip())\n+ if not re.fullmatch(r\"[0-9A-Za-z.\\-]{2,20}\", text):\n+ raise ValueError(\"hs_code may contain only letters, digits, dots, and hyphens\")\n+ return text\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/skills/SKILL.md b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/skills/SKILL.md\nnew file mode 100644\nindex 000000000..d3912ea4e\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/skills/SKILL.md\n@@ -0,0 +1,85 @@\n+---\n+name: cli-anything-web-yu-pri\n+description: Use Japan Post Web Yu-pri from a CLI by driving the real browser UI for login, inspection, screenshots, dry-run planning, and contents-form filling.\n+---\n+\n+# Web Yu-pri CLI\n+\n+Use this skill when a task involves Japan Post Web Yu-pri label entry at\n+`https://mgr.post.japanpost.jp/C30P01Action.do`, especially repetitive contents\n+line entry.\n+\n+## Install\n+\n+```bash\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\n+```\n+\n+If no browser is found:\n+\n+```bash\n+python -m playwright install chromium\n+```\n+\n+## Safety Rules\n+\n+- Do not put Japan Post credentials in commands, files, logs, or prompts.\n+- Use `open-login` so the user can log in manually in the persistent profile.\n+- Run `contents fill ... --dry-run --json` before live form filling.\n+- This CLI does not click final shipment confirmation or purchase buttons.\n+- Keep item lines separate when the source data has separate award/category\n+ lines, while preserving the requested declared total.\n+\n+## Common Commands\n+\n+```bash\n+cli-anything-web-yu-pri --json doctor\n+cli-anything-web-yu-pri open-login\n+cli-anything-web-yu-pri --json status --url https://mgr.post.japanpost.jp/M060800.do\n+cli-anything-web-yu-pri --json plan items.json\n+cli-anything-web-yu-pri --json contents fill items.json --dry-run\n+cli-anything-web-yu-pri --json contents fill items.json --total-value 17000\n+```\n+\n+## Items File\n+\n+JSON:\n+\n+```json\n+{\n+ \"items\": [\n+ {\"description\": \"Award plaque\", \"value\": 8000, \"quantity\": 1, \"country\": \"KR\"},\n+ {\"description\": \"Certificate\", \"value\": 9000, \"quantity\": 1, \"country\": \"KR\"}\n+ ]\n+}\n+```\n+\n+CSV headers can use these aliases:\n+\n+- description: `description`, `desc`, `content`, `contents`, `item`, `name`, `pkg`\n+- value: `value`, `declared_value`, `cost`, `price`, `amount`, `yen`, `jpy`\n+- quantity: `quantity`, `qty`, `num`, `count`\n+- country: `country`, `country_code`, `country_of_origin`, `origin`, `couCd`, `cou_cd`\n+- HS code: `hs_code`, `hs`, `hscode`, `hsCode`\n+\n+By default, `value` is treated as the line declared value. Use `--value-mode unit`\n+when value should be multiplied by quantity.\n+\n+## Selector Diagnostics\n+\n+```bash\n+cli-anything-web-yu-pri --json selectors\n+cli-anything-web-yu-pri snapshot --url https://mgr.post.japanpost.jp/M060800.do -o page.png --html-output page.html\n+```\n+\n+Known contents-page controls:\n+\n+- `#M060800_itemBean_pkg`\n+- `#M060800_itemBean_cost_value`\n+- `#M060800_itemBean_num_value`\n+- `#M060800_itemBean_couCd`\n+- `#M060800_itemBean_hsCode`\n+- `#M060800_shippingBean_pkgType`\n+- `#M060800_shippingBean_pkgTotalPrice_value`\n+- `#M060800_ShippingBean_danger`\n+- `submitCommand('itemAdd2')`\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/__init__.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/__init__.py\nnew file mode 100644\nindex 000000000..d7e127ba1\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/__init__.py\n@@ -0,0 +1,1 @@\n+\"\"\"Utility modules for the Web Yu-pri harness.\"\"\"\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/repl_skin.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/repl_skin.py\nnew file mode 100644\nindex 000000000..bc1fb6d1d\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/repl_skin.py\n@@ -0,0 +1,567 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ self.display_name = software.replace(\"_\", \" \").title()\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = self._c(_DARK_GRAY, f\" {'───'.join([_H_LINE * w for w in col_widths])}\")\n+ print(sep_line)\n+\n+ # Rows\n+ for row in rows:\n+ cells = []\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\n+ row_sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ print(f\" {row_sep.join(cells)}\")\n+\n+ # ── Help display ──────────────────────────────────────────────────\n+\n+ def help(self, commands: dict[str, str]):\n+ \"\"\"Print a formatted help listing.\n+\n+ Args:\n+ commands: Dict of command -> description pairs.\n+ \"\"\"\n+ self.section(\"Commands\")\n+ max_cmd = max(len(c) for c in commands) if commands else 0\n+ for cmd, desc in commands.items():\n+ cmd_styled = self._c(self.accent, f\" {cmd:<{max_cmd}}\")\n+ desc_styled = self._c(_GRAY, f\" {desc}\")\n+ print(f\"{cmd_styled}{desc_styled}\")\n+ print()\n+\n+ # ── Goodbye ───────────────────────────────────────────────────────\n+\n+ def print_goodbye(self):\n+ \"\"\"Print a styled goodbye message.\"\"\"\n+ print(f\"\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\n\")\n+\n+ # ── Prompt toolkit session factory ────────────────────────────────\n+\n+ def create_prompt_session(self):\n+ \"\"\"Create a prompt_toolkit PromptSession with skin styling.\n+\n+ Returns:\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\n+ \"\"\"\n+ try:\n+ from prompt_toolkit import PromptSession\n+ from prompt_toolkit.history import FileHistory\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\n+ from prompt_toolkit.formatted_text import FormattedText\n+\n+ style = self.get_prompt_style()\n+\n+ session = PromptSession(\n+ history=FileHistory(self.history_file),\n+ auto_suggest=AutoSuggestFromHistory(),\n+ style=style,\n+ enable_history_search=True,\n+ )\n+ return session\n+ except ImportError:\n+ return None\n+\n+ def get_input(self, pt_session, project_name: str = \"\",\n+ modified: bool = False, context: str = \"\") -> str:\n+ \"\"\"Get input from user using prompt_toolkit or fallback.\n+\n+ Args:\n+ pt_session: A prompt_toolkit PromptSession (or None).\n+ project_name: Current project name.\n+ modified: Whether project has unsaved changes.\n+ context: Optional context string.\n+\n+ Returns:\n+ User input string (stripped).\n+ \"\"\"\n+ if pt_session is not None:\n+ from prompt_toolkit.formatted_text import FormattedText\n+ tokens = self.prompt_tokens(project_name, modified, context)\n+ return pt_session.prompt(FormattedText(tokens)).strip()\n+ else:\n+ raw_prompt = self.prompt(project_name, modified, context)\n+ return input(raw_prompt).strip()\n+\n+ # ── Toolbar builder ───────────────────────────────────────────────\n+\n+ def bottom_toolbar(self, items: dict[str, str]):\n+ \"\"\"Create a bottom toolbar callback for prompt_toolkit.\n+\n+ Args:\n+ items: Dict of label -> value pairs to show in toolbar.\n+\n+ Returns:\n+ A callable that returns FormattedText for the toolbar.\n+ \"\"\"\n+ def toolbar():\n+ from prompt_toolkit.formatted_text import FormattedText\n+ parts = []\n+ for i, (k, v) in enumerate(items.items()):\n+ if i > 0:\n+ parts.append((\"class:bottom-toolbar.text\", \" │ \"))\n+ parts.append((\"class:bottom-toolbar.text\", f\" {k}: \"))\n+ parts.append((\"class:bottom-toolbar\", v))\n+ return FormattedText(parts)\n+ return toolbar\n+\n+\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\n+\n+_ANSI_256_TO_HEX = {\n+ \"\\033[38;5;33m\": \"#0087ff\", # audacity navy blue\n+ \"\\033[38;5;35m\": \"#00af5f\", # shotcut teal\n+ \"\\033[38;5;39m\": \"#00afff\", # inkscape bright blue\n+ \"\\033[38;5;40m\": \"#00d700\", # libreoffice green\n+ \"\\033[38;5;55m\": \"#5f00af\", # obs purple\n+ \"\\033[38;5;69m\": \"#5f87ff\", # kdenlive slate blue\n+ \"\\033[38;5;75m\": \"#5fafff\", # default sky blue\n+ \"\\033[38;5;80m\": \"#5fd7d7\", # brand cyan\n+ \"\\033[38;5;208m\": \"#ff8700\", # blender deep orange\n+ \"\\033[38;5;214m\": \"#ffaf00\", # gimp warm orange\n+}\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/web_yu_pri_cli.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/web_yu_pri_cli.py\nnew file mode 100644\nindex 000000000..8d19764e8\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/web_yu_pri_cli.py\n@@ -0,0 +1,350 @@\n+#!/usr/bin/env python3\n+\"\"\"CLI harness for Japan Post Web Yu-pri.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from contextlib import contextmanager\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.web_yu_pri import __version__\n+from cli_anything.web_yu_pri.core.browser import (\n+ CONTENTS_URL,\n+ LOGIN_URL,\n+ build_dry_run,\n+ capture_snapshot,\n+ doctor as browser_doctor,\n+ fill_contents,\n+ inspect_url,\n+ open_login,\n+ selector_report,\n+)\n+from cli_anything.web_yu_pri.core.items import build_contents_plan, load_items\n+\n+_json_output = False\n+_profile_dir: str | None = None\n+\n+\n+def emit(data: Any, message: str | None = None) -> None:\n+ if _json_output:\n+ click.echo(json.dumps(data, ensure_ascii=False, indent=2, default=str))\n+ else:\n+ if message:\n+ click.echo(message)\n+ if isinstance(data, dict):\n+ _print_dict(data)\n+ elif isinstance(data, list):\n+ _print_list(data)\n+ elif data is not None:\n+ click.echo(str(data))\n+\n+\n+def fail(message: str, error_type: str = \"runtime_error\") -> None:\n+ if _json_output:\n+ click.echo(json.dumps({\"error\": message, \"type\": error_type}, ensure_ascii=False))\n+ else:\n+ click.echo(f\"Error: {message}\", err=True)\n+ raise SystemExit(1)\n+\n+\n+def _print_dict(data: dict[str, Any], indent: int = 0) -> None:\n+ prefix = \" \" * indent\n+ for key, value in data.items():\n+ if isinstance(value, dict):\n+ click.echo(f\"{prefix}{key}:\")\n+ _print_dict(value, indent + 1)\n+ elif isinstance(value, list):\n+ click.echo(f\"{prefix}{key}:\")\n+ _print_list(value, indent + 1)\n+ else:\n+ click.echo(f\"{prefix}{key}: {value}\")\n+\n+\n+def _print_list(values: list[Any], indent: int = 0) -> None:\n+ prefix = \" \" * indent\n+ for index, value in enumerate(values):\n+ if isinstance(value, dict):\n+ click.echo(f\"{prefix}[{index}]\")\n+ _print_dict(value, indent + 1)\n+ else:\n+ click.echo(f\"{prefix}- {value}\")\n+\n+\n+def _load_plan(\n+ items_file: str,\n+ default_country: str | None,\n+ total_value: int | None,\n+ value_mode: str,\n+) -> tuple[list[Any], dict[str, Any]]:\n+ path = Path(items_file).expanduser()\n+ if not path.is_file():\n+ raise FileNotFoundError(f\"items file not found: {items_file}\")\n+ items = load_items(path, default_country=default_country)\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ return items, plan\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--json\", \"json_output\", is_flag=True, help=\"Output machine-readable JSON.\")\n+@click.option(\n+ \"--profile-dir\",\n+ type=click.Path(file_okay=False, dir_okay=True, path_type=str),\n+ default=None,\n+ help=\"Persistent browser profile directory. Defaults to ~/.cli-anything-web-yu-pri/profile.\",\n+)\n+@click.version_option(version=__version__)\n+@click.pass_context\n+def cli(ctx: click.Context, json_output: bool, profile_dir: str | None) -> None:\n+ \"\"\"Japan Post Web Yu-pri browser automation harness.\n+\n+ Run with --json for agent-safe output. Commands that touch the real site use a\n+ persistent local browser profile and never store account passwords.\n+ \"\"\"\n+\n+ global _json_output, _profile_dir\n+ _json_output = json_output\n+ _profile_dir = profile_dir\n+ if ctx.invoked_subcommand is None:\n+ click.echo(ctx.get_help())\n+\n+\n+@cli.command(\"doctor\")\n+def doctor_cmd() -> None:\n+ \"\"\"Check local runtime and profile paths.\"\"\"\n+\n+ try:\n+ emit(browser_doctor(profile_dir=_profile_dir))\n+ except Exception as exc:\n+ fail(str(exc))\n+\n+\n+@cli.command(\"selectors\")\n+def selectors_cmd() -> None:\n+ \"\"\"Print the currently known Web Yu-pri selector map.\"\"\"\n+\n+ emit(selector_report())\n+\n+\n+@cli.command(\"plan\")\n+@click.argument(\"items_file\", type=str)\n+@click.option(\"--country-default\", default=None, help=\"Default ISO country code for rows without one.\")\n+@click.option(\"--total-value\", type=int, default=None, help=\"Override the declared total value in yen.\")\n+@click.option(\n+ \"--value-mode\",\n+ type=click.Choice([\"line\", \"unit\"]),\n+ default=\"line\",\n+ show_default=True,\n+ help=\"Treat item value as a line total or a unit value.\",\n+)\n+def plan_cmd(items_file: str, country_default: str | None, total_value: int | None, value_mode: str) -> None:\n+ \"\"\"Validate an items JSON/CSV/TSV file and print the fill plan.\"\"\"\n+\n+ try:\n+ _items, plan = _load_plan(items_file, country_default, total_value, value_mode)\n+ emit(plan)\n+ except Exception as exc:\n+ fail(str(exc), error_type=type(exc).__name__)\n+\n+\n+@cli.command(\"open-login\")\n+@click.option(\"--url\", default=LOGIN_URL, show_default=True, help=\"Login/start URL to open.\")\n+@click.option(\"--headless\", is_flag=True, help=\"Run browser headless.\")\n+@click.option(\"--browser-channel\", default=None, help=\"Playwright channel, for example msedge or chrome.\")\n+@click.option(\n+ \"--wait/--no-wait\",\n+ default=None,\n+ help=\"Keep the browser open until Enter is pressed. Defaults to on for human output and off for --json.\",\n+)\n+def open_login_cmd(url: str, headless: bool, browser_channel: str | None, wait: bool | None) -> None:\n+ \"\"\"Open the Web Yu-pri login/start page in the persistent profile.\"\"\"\n+\n+ try:\n+ should_wait = (not _json_output) if wait is None else wait\n+ if should_wait:\n+ with _interactive_session(url, headless=headless, browser_channel=browser_channel) as info:\n+ emit(info, \"Opened Web Yu-pri login page.\")\n+ if not _json_output:\n+ click.echo(\"Log in or inspect the page, then press Enter here to close the browser.\")\n+ input()\n+ else:\n+ info = open_login(url=url, profile_dir=_profile_dir, headless=headless, browser_channel=browser_channel)\n+ emit(info, \"Opened Web Yu-pri login page.\")\n+ except KeyboardInterrupt:\n+ return\n+ except Exception as exc:\n+ fail(str(exc), error_type=type(exc).__name__)\n+\n+\n+@cli.command(\"status\")\n+@click.option(\"--url\", default=LOGIN_URL, show_default=True, help=\"URL to inspect.\")\n+@click.option(\"--headless\", is_flag=True, help=\"Run browser headless.\")\n+@click.option(\"--browser-channel\", default=None, help=\"Playwright channel, for example msedge or chrome.\")\n+def status_cmd(url: str, headless: bool, browser_channel: str | None) -> None:\n+ \"\"\"Open a URL and report title, current URL, and selector presence.\"\"\"\n+\n+ try:\n+ emit(inspect_url(url=url, profile_dir=_profile_dir, headless=headless, browser_channel=browser_channel))\n+ except Exception as exc:\n+ fail(str(exc), error_type=type(exc).__name__)\n+\n+\n+@cli.command(\"snapshot\")\n+@click.option(\"--url\", default=LOGIN_URL, show_default=True, help=\"URL to capture.\")\n+@click.option(\n+ \"-o\",\n+ \"--output\",\n+ required=True,\n+ type=click.Path(dir_okay=False, path_type=str),\n+ help=\"PNG screenshot output path.\",\n+)\n+@click.option(\n+ \"--html-output\",\n+ type=click.Path(dir_okay=False, path_type=str),\n+ default=None,\n+ help=\"Optional HTML dump output path.\",\n+)\n+@click.option(\"--headless\", is_flag=True, help=\"Run browser headless.\")\n+@click.option(\"--browser-channel\", default=None, help=\"Playwright channel, for example msedge or chrome.\")\n+def snapshot_cmd(\n+ url: str,\n+ output: str,\n+ html_output: str | None,\n+ headless: bool,\n+ browser_channel: str | None,\n+) -> None:\n+ \"\"\"Capture a screenshot, and optionally HTML, for the current form state.\"\"\"\n+\n+ try:\n+ result = capture_snapshot(\n+ url=url,\n+ output=output,\n+ html_output=html_output,\n+ profile_dir=_profile_dir,\n+ headless=headless,\n+ browser_channel=browser_channel,\n+ )\n+ emit(result, \"Snapshot captured.\")\n+ except Exception as exc:\n+ fail(str(exc), error_type=type(exc).__name__)\n+\n+\n+@cli.group()\n+def contents() -> None:\n+ \"\"\"Commands for the shipment contents form.\"\"\"\n+\n+\n+@contents.command(\"fill\")\n+@click.argument(\"items_file\", type=str)\n+@click.option(\"--url\", default=CONTENTS_URL, show_default=True, help=\"Contents form URL.\")\n+@click.option(\"--country-default\", default=None, help=\"Default ISO country code for rows without one.\")\n+@click.option(\"--total-value\", type=int, default=None, help=\"Override the declared total value in yen.\")\n+@click.option(\n+ \"--value-mode\",\n+ type=click.Choice([\"line\", \"unit\"]),\n+ default=\"line\",\n+ show_default=True,\n+ help=\"Treat item value as a line total or a unit value.\",\n+)\n+@click.option(\"--package-type\", default=None, help=\"Optional package type/select value.\")\n+@click.option(\"--danger/--no-danger\", default=None, help=\"Set the dangerous-goods flag when present.\")\n+@click.option(\"--dry-run\", is_flag=True, help=\"Validate and print the plan without opening a browser.\")\n+@click.option(\"--headless\", is_flag=True, help=\"Run browser headless.\")\n+@click.option(\"--browser-channel\", default=None, help=\"Playwright channel, for example msedge or chrome.\")\n+@click.option(\"--delay-ms\", type=int, default=500, show_default=True, help=\"Delay after adding each item.\")\n+def contents_fill_cmd(\n+ items_file: str,\n+ url: str,\n+ country_default: str | None,\n+ total_value: int | None,\n+ value_mode: str,\n+ package_type: str | None,\n+ danger: bool | None,\n+ dry_run: bool,\n+ headless: bool,\n+ browser_channel: str | None,\n+ delay_ms: int,\n+) -> None:\n+ \"\"\"Fill item lines on the Web Yu-pri contents page.\n+\n+ This command stops after filling contents and the declared total. It does not\n+ click the final shipment confirmation/submit button.\n+ \"\"\"\n+\n+ try:\n+ items, _plan = _load_plan(items_file, country_default, total_value, value_mode)\n+ if dry_run:\n+ emit(\n+ build_dry_run(\n+ items,\n+ total_value=total_value,\n+ value_mode=value_mode,\n+ package_type=package_type,\n+ danger=danger,\n+ )\n+ )\n+ return\n+ result = fill_contents(\n+ items,\n+ total_value=total_value,\n+ value_mode=value_mode,\n+ url=url,\n+ profile_dir=_profile_dir,\n+ package_type=package_type,\n+ danger=danger,\n+ headless=headless,\n+ browser_channel=browser_channel,\n+ delay_ms=delay_ms,\n+ )\n+ emit(result, \"Contents filled.\")\n+ except Exception as exc:\n+ fail(str(exc), error_type=type(exc).__name__)\n+\n+\n+@cli.command(\"repl\")\n+def repl_cmd() -> None:\n+ \"\"\"Start a small command REPL.\"\"\"\n+\n+ click.echo(\"cli-anything-web-yu-pri REPL. Type help or exit.\")\n+ while True:\n+ try:\n+ line = input(\"web-yu-pri> \").strip()\n+ except (EOFError, KeyboardInterrupt):\n+ click.echo()\n+ return\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ return\n+ if line == \"help\":\n+ click.echo(\"Try: doctor, selectors, plan <items.json>, contents fill <items.json> --dry-run\")\n+ continue\n+ try:\n+ cli.main(args=shlex.split(line), prog_name=\"cli-anything-web-yu-pri\", standalone_mode=False)\n+ except SystemExit:\n+ pass\n+ except Exception as exc:\n+ click.echo(f\"Error: {exc}\", err=True)\n+\n+\n+@contextmanager\n+def _interactive_session(url: str, headless: bool, browser_channel: str | None):\n+ from cli_anything.web_yu_pri.core.browser import browser_session, inspect_page\n+\n+ with browser_session(profile_dir=_profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ yield inspect_page(page)\n+\n+\n+def main() -> None:\n+ cli()\n+\n+\n+if __name__ == \"__main__\":\n+ main()\ndiff --git a/web-yu-pri/agent-harness/setup.py b/web-yu-pri/agent-harness/setup.py\nnew file mode 100644\nindex 000000000..bcd25404e\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/setup.py\n@@ -0,0 +1,65 @@\n+#!/usr/bin/env python3\n+from pathlib import Path\n+from setuptools import find_namespace_packages, setup\n+\n+ROOT = Path(__file__).parent\n+README = ROOT / \"README.md\"\n+\n+\n+def read_readme():\n+ try:\n+ return README.read_text(encoding=\"utf-8\")\n+ except FileNotFoundError:\n+ return \"\"\n+\n+\n+setup(\n+ name=\"cli-anything-web-yu-pri\",\n+ version=\"0.1.0\",\n+ author=\"CLI Anything Contributors\",\n+ description=\"CLI harness for Japan Post Web Yu-pri label workflows\",\n+ long_description=read_readme(),\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ project_urls={\n+ \"Homepage\": \"https://github.com/HKUDS/CLI-Anything\",\n+ \"Issues\": \"https://github.com/HKUDS/CLI-Anything/issues\",\n+ },\n+ license=\"MIT\",\n+ packages=find_namespace_packages(include=[\"cli_anything.*\"]),\n+ python_requires=\">=3.10\",\n+ install_requires=[\n+ \"click>=8.1,<9.0\",\n+ \"playwright>=1.45,<2.0\",\n+ ],\n+ extras_require={\n+ \"dev\": [\n+ \"pytest>=7\",\n+ \"build\",\n+ \"twine\",\n+ ],\n+ },\n+ entry_points={\n+ \"console_scripts\": [\n+ \"cli-anything-web-yu-pri=cli_anything.web_yu_pri.web_yu_pri_cli:main\",\n+ ],\n+ },\n+ package_data={\n+ \"cli_anything.web_yu_pri\": [\"skills/*.md\"],\n+ },\n+ include_package_data=True,\n+ zip_safe=False,\n+ keywords=\"cli japan-post web-yu-pri shipping labels browser-automation ai-agent\",\n+ classifiers=[\n+ \"Development Status :: 3 - Alpha\",\n+ \"Intended Audience :: Developers\",\n+ \"Topic :: Internet :: WWW/HTTP :: Browsers\",\n+ \"Topic :: Office/Business\",\n+ \"Topic :: Software Development :: Testing\",\n+ \"License :: OSI Approved :: MIT License\",\n+ \"Programming Language :: Python :: 3 :: Only\",\n+ \"Programming Language :: Python :: 3.10\",\n+ \"Programming Language :: Python :: 3.11\",\n+ \"Programming Language :: Python :: 3.12\",\n+ ],\n+)\n"},"changed_files":{"kind":"list like","value":[".gitignore","README.md","registry.json","skills/cli-anything-web-yu-pri/SKILL.md","web-yu-pri/agent-harness/README.md","web-yu-pri/agent-harness/WEB_YU_PRI.md","web-yu-pri/agent-harness/cli_anything/web_yu_pri/README.md","web-yu-pri/agent-harness/cli_anything/web_yu_pri/__init__.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/__main__.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/__init__.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/items.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/skills/SKILL.md","web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/TEST.md","web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/__init__.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_core.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_full_e2e.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/__init__.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/repl_skin.py","web-yu-pri/agent-harness/cli_anything/web_yu_pri/web_yu_pri_cli.py","web-yu-pri/agent-harness/setup.py"],"string":"[\n \".gitignore\",\n \"README.md\",\n \"registry.json\",\n \"skills/cli-anything-web-yu-pri/SKILL.md\",\n \"web-yu-pri/agent-harness/README.md\",\n \"web-yu-pri/agent-harness/WEB_YU_PRI.md\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/README.md\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/__init__.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/__main__.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/__init__.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/items.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/skills/SKILL.md\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/TEST.md\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/__init__.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_core.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_full_e2e.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/__init__.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/utils/repl_skin.py\",\n \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/web_yu_pri_cli.py\",\n \"web-yu-pri/agent-harness/setup.py\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"**<sub><sub></sub></sub> Keep the login browser open for manual authentication**\n\nWhen a user runs `open-login` to establish the persistent profile, this function navigates to the login URL and then immediately exits the `with browser_session(...)` block, which closes the Playwright context in `finally`. In the documented quick-start/manual-login flow this leaves only a briefly flashing window, so users cannot actually complete the Japan Post login and save the session for later `status` or `contents fill` commands.\n\nUseful? React with 👍 / 👎.","path":"web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py","hunk":"@@ -0,0 +1,383 @@\n+\"\"\"Playwright backend for the real Web Yu-pri web application.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import time\n+from contextlib import contextmanager\n+from pathlib import Path\n+from typing import Any, Iterator\n+\n+from .items import ItemLine, build_contents_plan\n+\n+LOGIN_URL = \"https://mgr.post.japanpost.jp/C30P01Action.do\"\n+CONTENTS_URL = \"https://mgr.post.japanpost.jp/M060800.do\"\n+\n+SELECTORS = {\n+ \"item_description\": \"#M060800_itemBean_pkg\",\n+ \"item_value\": \"#M060800_itemBean_cost_value\",\n+ \"item_quantity\": \"#M060800_itemBean_num_value\",\n+ \"item_country\": \"#M060800_itemBean_couCd\",\n+ \"item_hs_code\": \"#M060800_itemBean_hsCode\",\n+ \"package_type\": \"#M060800_shippingBean_pkgType\",\n+ \"total_value\": \"#M060800_shippingBean_pkgTotalPrice_value\",\n+ \"danger\": \"#M060800_ShippingBean_danger\",\n+}\n+\n+ADD_ITEM_COMMAND = \"itemAdd2\"\n+\n+\n+def default_profile_dir() -> Path:\n+ return Path.home() / \".cli-anything-web-yu-pri\" / \"profile\"\n+\n+\n+def selector_report() -> dict[str, Any]:\n+ return {\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ }\n+\n+\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\n+ result: dict[str, Any] = {\n+ \"profile_dir\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"playwright_available\": False,\n+ \"notes\": [],\n+ }\n+ try:\n+ import playwright # noqa: F401\n+\n+ result[\"playwright_available\"] = True\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\n+ result[\"notes\"].append(f\"playwright import failed: {exc}\")\n+ return result\n+\n+\n+@contextmanager\n+def browser_session(\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> Iterator[tuple[Any, Any]]:\n+ \"\"\"Launch a persistent browser context and yield (page, context).\"\"\"\n+\n+ try:\n+ from playwright.sync_api import Error as PlaywrightError\n+ from playwright.sync_api import sync_playwright\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\n+ raise RuntimeError(\n+ \"playwright is required. Install with: pip install cli-anything-web-yu-pri\"\n+ ) from exc\n+\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\n+\n+ playwright = sync_playwright().start()\n+ context = None\n+ errors: list[str] = []\n+ channels = [browser_channel] if browser_channel else [\"msedge\", \"chrome\", None]\n+ try:\n+ for channel in channels:\n+ try:\n+ kwargs: dict[str, Any] = {\n+ \"headless\": headless,\n+ \"args\": [\"--disable-blink-features=AutomationControlled\"],\n+ }\n+ if channel:\n+ kwargs[\"channel\"] = channel\n+ context = playwright.chromium.launch_persistent_context(\n+ str(user_data_dir),\n+ **kwargs,\n+ )\n+ break\n+ except PlaywrightError as exc:\n+ label = channel or \"bundled-chromium\"\n+ errors.append(f\"{label}: {exc}\")\n+ if context is None:\n+ detail = \" | \".join(errors) if errors else \"no browser channels attempted\"\n+ raise RuntimeError(f\"could not launch Chromium/Edge browser: {detail}\")\n+\n+ page = context.pages[0] if context.pages else context.new_page()\n+ yield page, context\n+ finally:\n+ if context is not None:\n+ context.close()\n+ playwright.stop()\n+\n+\n+def open_login(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)","resolving_sha":"76ddd417358ce0ec35ab2ef06dee090442061e77","resolving_diff":"diff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\nnew file mode 100644\nindex 000000000..148ca168c\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\n@@ -0,0 +1,383 @@\n+\"\"\"Playwright backend for the real Web Yu-pri web application.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import time\n+from contextlib import contextmanager\n+from pathlib import Path\n+from typing import Any, Iterator\n+\n+from .items import ItemLine, build_contents_plan\n+\n+LOGIN_URL = \"https://mgr.post.japanpost.jp/C30P01Action.do\"\n+CONTENTS_URL = \"https://mgr.post.japanpost.jp/M060800.do\"\n+\n+SELECTORS = {\n+ \"item_description\": \"#M060800_itemBean_pkg\",\n+ \"item_value\": \"#M060800_itemBean_cost_value\",\n+ \"item_quantity\": \"#M060800_itemBean_num_value\",\n+ \"item_country\": \"#M060800_itemBean_couCd\",\n+ \"item_hs_code\": \"#M060800_itemBean_hsCode\",\n+ \"package_type\": \"#M060800_shippingBean_pkgType\",\n+ \"total_value\": \"#M060800_shippingBean_pkgTotalPrice_value\",\n+ \"danger\": \"#M060800_ShippingBean_danger\",\n+}\n+\n+ADD_ITEM_COMMAND = \"itemAdd2\"\n+\n+\n+def default_profile_dir() -> Path:\n+ return Path.home() / \".cli-anything-web-yu-pri\" / \"profile\"\n+\n+\n+def selector_report() -> dict[str, Any]:\n+ return {\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ }\n+\n+\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\n+ result: dict[str, Any] = {\n+ \"profile_dir\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"playwright_available\": False,\n+ \"notes\": [],\n+ }\n+ try:\n+ import playwright # noqa: F401\n+\n+ result[\"playwright_available\"] = True\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\n+ result[\"notes\"].append(f\"playwright import failed: {exc}\")\n+ return result\n+\n+\n+@contextmanager\n+def browser_session(\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> Iterator[tuple[Any, Any]]:\n+ \"\"\"Launch a persistent browser context and yield (page, context).\"\"\"\n+\n+ try:\n+ from playwright.sync_api import Error as PlaywrightError\n+ from playwright.sync_api import sync_playwright\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\n+ raise RuntimeError(\n+ \"playwright is required. Install with: pip install cli-anything-web-yu-pri\"\n+ ) from exc\n+\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\n+\n+ playwright = sync_playwright().start()\n+ context = None\n+ errors: list[str] = []\n+ channels = [browser_channel] if browser_channel else [\"msedge\", \"chrome\", None]\n+ try:\n+ for channel in channels:\n+ try:\n+ kwargs: dict[str, Any] = {\n+ \"headless\": headless,\n+ \"args\": [\"--disable-blink-features=AutomationControlled\"],\n+ }\n+ if channel:\n+ kwargs[\"channel\"] = channel\n+ context = playwright.chromium.launch_persistent_context(\n+ str(user_data_dir),\n+ **kwargs,\n+ )\n+ break\n+ except PlaywrightError as exc:\n+ label = channel or \"bundled-chromium\"\n+ errors.append(f\"{label}: {exc}\")\n+ if context is None:\n+ detail = \" | \".join(errors) if errors else \"no browser channels attempted\"\n+ raise RuntimeError(f\"could not launch Chromium/Edge browser: {detail}\")\n+\n+ page = context.pages[0] if context.pages else context.new_page()\n+ yield page, context\n+ finally:\n+ if context is not None:\n+ context.close()\n+ playwright.stop()\n+\n+\n+def open_login(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def inspect_url(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def capture_snapshot(\n+ url: str,\n+ output: str | Path,\n+ html_output: str | Path | None = None,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ output_path = Path(output).expanduser().resolve()\n+ output_path.parent.mkdir(parents=True, exist_ok=True)\n+ html_path = Path(html_output).expanduser().resolve() if html_output else None\n+ if html_path:\n+ html_path.parent.mkdir(parents=True, exist_ok=True)\n+\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ page.screenshot(path=str(output_path), full_page=True)\n+ if html_path:\n+ html_path.write_text(page.content(), encoding=\"utf-8\")\n+ info = inspect_page(page)\n+ info[\"screenshot\"] = str(output_path)\n+ if html_path:\n+ info[\"html\"] = str(html_path)\n+ return info\n+\n+\n+def inspect_page(page: Any) -> dict[str, Any]:\n+ \"\"\"Return cheap, JSON-safe page facts.\"\"\"\n+\n+ selector_presence = {\n+ name: page.locator(selector).count() > 0 for name, selector in SELECTORS.items()\n+ }\n+ return {\n+ \"url\": page.url,\n+ \"title\": page.title(),\n+ \"has_contents_form\": all(\n+ selector_presence[key]\n+ for key in (\"item_description\", \"item_value\", \"item_quantity\", \"total_value\")\n+ ),\n+ \"selectors\": selector_presence,\n+ }\n+\n+\n+def fill_contents(\n+ items: list[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+ url: str = CONTENTS_URL,\n+ profile_dir: str | Path | None = None,\n+ package_type: str | None = None,\n+ danger: bool | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+ delay_ms: int = 500,\n+) -> dict[str, Any]:\n+ \"\"\"Fill the known Web Yu-pri contents form and add each item line.\"\"\"\n+\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ _require_selector(page, SELECTORS[\"item_description\"])\n+\n+ if package_type:\n+ _set_value(page, SELECTORS[\"package_type\"], package_type)\n+ if danger is not None:\n+ _set_boolean(page, SELECTORS[\"danger\"], danger)\n+\n+ added: list[dict[str, Any]] = []\n+ for item in items:\n+ _fill_item(page, item)\n+ before = _body_fingerprint(page)\n+ _run_submit_command(page, ADD_ITEM_COMMAND)\n+ _wait_after_submit(page, before=before, delay_ms=delay_ms)\n+ added.append(\n+ {\n+ \"description\": item.description,\n+ \"value\": item.value,\n+ \"quantity\": item.quantity,\n+ \"country\": item.country,\n+ \"hs_code\": item.hs_code,\n+ }\n+ )\n+\n+ _set_value(page, SELECTORS[\"total_value\"], str(plan[\"declared_total\"]))\n+ info = inspect_page(page)\n+ verification = _verify_descriptions(page, [item.description for item in items])\n+ return {\n+ \"status\": \"filled\",\n+ \"plan\": plan,\n+ \"added\": added,\n+ \"page\": info,\n+ \"verification\": verification,\n+ \"safety\": {\n+ \"final_submit_clicked\": False,\n+ \"message\": \"Contents were filled only; final shipment confirmation is not clicked.\",\n+ },\n+ }\n+\n+\n+def build_dry_run(\n+ items: list[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+ package_type: str | None = None,\n+ danger: bool | None = None,\n+) -> dict[str, Any]:\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ return {\n+ \"dry_run\": True,\n+ \"plan\": plan,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ \"package_type\": package_type,\n+ \"danger\": danger,\n+ \"safety\": {\n+ \"browser_launched\": False,\n+ \"final_submit_clicked\": False,\n+ },\n+ }\n+\n+\n+def _fill_item(page: Any, item: ItemLine) -> None:\n+ _set_value(page, SELECTORS[\"item_description\"], item.description)\n+ _set_value(page, SELECTORS[\"item_value\"], str(item.value))\n+ _set_value(page, SELECTORS[\"item_quantity\"], str(item.quantity))\n+ if item.country:\n+ _set_value(page, SELECTORS[\"item_country\"], item.country)\n+ if item.hs_code:\n+ _set_value(page, SELECTORS[\"item_hs_code\"], item.hs_code)\n+\n+\n+def _require_selector(page: Any, selector: str, timeout_ms: int = 15_000) -> None:\n+ try:\n+ page.wait_for_selector(selector, timeout=timeout_ms)\n+ except Exception as exc:\n+ info = {\n+ \"url\": page.url,\n+ \"title\": page.title(),\n+ \"expected_selector\": selector,\n+ }\n+ raise RuntimeError(\n+ \"Web Yu-pri contents form was not found. \"\n+ f\"Page facts: {json.dumps(info, ensure_ascii=False)}\"\n+ ) from exc\n+\n+\n+def _set_value(page: Any, selector: str, value: str) -> None:\n+ locator = page.locator(selector)\n+ if locator.count() == 0:\n+ return\n+ try:\n+ tag_name = locator.first.evaluate(\"el => el.tagName.toLowerCase()\")\n+ if tag_name == \"select\":\n+ locator.first.select_option(value)\n+ else:\n+ locator.first.fill(str(value))\n+ except Exception:\n+ locator.first.evaluate(\n+ \"\"\"(el, value) => {\n+ el.value = value;\n+ el.dispatchEvent(new Event('input', {bubbles: true}));\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\n+ }\"\"\",\n+ str(value),\n+ )\n+\n+\n+def _set_boolean(page: Any, selector: str, value: bool) -> None:\n+ locator = page.locator(selector)\n+ if locator.count() == 0:\n+ return\n+ try:\n+ input_type = locator.first.evaluate(\"el => (el.type || '').toLowerCase()\")\n+ if input_type in {\"checkbox\", \"radio\"}:\n+ locator.first.set_checked(value)\n+ return\n+ except Exception:\n+ pass\n+ locator.first.evaluate(\n+ \"\"\"(el, value) => {\n+ el.checked = Boolean(value);\n+ el.value = value ? '1' : '';\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\n+ }\"\"\",\n+ value,\n+ )\n+\n+\n+def _run_submit_command(page: Any, command: str) -> None:\n+ page.evaluate(\n+ \"\"\"command => {\n+ if (typeof window.submitCommand === 'function') {\n+ window.submitCommand(command);\n+ return;\n+ }\n+ throw new Error('submitCommand is not available on this page');\n+ }\"\"\",\n+ command,\n+ )\n+\n+\n+def _wait_after_submit(page: Any, before: str, delay_ms: int) -> None:\n+ try:\n+ page.wait_for_load_state(\"domcontentloaded\", timeout=10_000)\n+ except Exception:\n+ pass\n+ deadline = time.time() + 10\n+ while time.time() < deadline:\n+ time.sleep(max(delay_ms, 100) / 1000)\n+ if _body_fingerprint(page) != before:\n+ return\n+\n+\n+def _body_fingerprint(page: Any) -> str:\n+ try:\n+ return page.evaluate(\n+ \"\"\"() => {\n+ const text = document.body ? document.body.innerText : '';\n+ const inputs = Array.from(document.querySelectorAll('input,select,textarea'))\n+ .slice(0, 200)\n+ .map(el => `${el.id || el.name || ''}:${el.value || ''}`)\n+ .join('|');\n+ return `${location.href}|${text.length}|${inputs.length}|${inputs}`;\n+ }\"\"\"\n+ )\n+ except Exception:\n+ return f\"{page.url}:{time.time()}\"\n+\n+\n+def _verify_descriptions(page: Any, descriptions: list[str]) -> dict[str, Any]:\n+ body_text = page.evaluate(\"() => document.body ? document.body.innerText : ''\")\n+ found = [description for description in descriptions if description in body_text]\n+ missing = [description for description in descriptions if description not in body_text]\n+ return {\n+ \"descriptions_found\": found,\n+ \"descriptions_missing\": missing,\n+ \"all_found\": not missing,\n+ }\n"},{"comment":"**<sub><sub></sub></sub> Fail before submitting when required fields are absent**\n\nFor live `contents fill`, only the description selector is required before submitting each row; if the value, quantity, or total selectors are missing because Web Yu-pri changed the form or the user landed on a partial/wrong page, `_set_value` silently no-ops and the code still calls `submitCommand('itemAdd2')`. That can add incomplete or default-valued rows while reporting success, so the command should require all mandatory selectors before it starts submitting items.\n\nUseful? React with 👍 / 👎.","path":"web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py","hunk":"@@ -0,0 +1,383 @@\n+\"\"\"Playwright backend for the real Web Yu-pri web application.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import time\n+from contextlib import contextmanager\n+from pathlib import Path\n+from typing import Any, Iterator\n+\n+from .items import ItemLine, build_contents_plan\n+\n+LOGIN_URL = \"https://mgr.post.japanpost.jp/C30P01Action.do\"\n+CONTENTS_URL = \"https://mgr.post.japanpost.jp/M060800.do\"\n+\n+SELECTORS = {\n+ \"item_description\": \"#M060800_itemBean_pkg\",\n+ \"item_value\": \"#M060800_itemBean_cost_value\",\n+ \"item_quantity\": \"#M060800_itemBean_num_value\",\n+ \"item_country\": \"#M060800_itemBean_couCd\",\n+ \"item_hs_code\": \"#M060800_itemBean_hsCode\",\n+ \"package_type\": \"#M060800_shippingBean_pkgType\",\n+ \"total_value\": \"#M060800_shippingBean_pkgTotalPrice_value\",\n+ \"danger\": \"#M060800_ShippingBean_danger\",\n+}\n+\n+ADD_ITEM_COMMAND = \"itemAdd2\"\n+\n+\n+def default_profile_dir() -> Path:\n+ return Path.home() / \".cli-anything-web-yu-pri\" / \"profile\"\n+\n+\n+def selector_report() -> dict[str, Any]:\n+ return {\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ }\n+\n+\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\n+ result: dict[str, Any] = {\n+ \"profile_dir\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"playwright_available\": False,\n+ \"notes\": [],\n+ }\n+ try:\n+ import playwright # noqa: F401\n+\n+ result[\"playwright_available\"] = True\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\n+ result[\"notes\"].append(f\"playwright import failed: {exc}\")\n+ return result\n+\n+\n+@contextmanager\n+def browser_session(\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> Iterator[tuple[Any, Any]]:\n+ \"\"\"Launch a persistent browser context and yield (page, context).\"\"\"\n+\n+ try:\n+ from playwright.sync_api import Error as PlaywrightError\n+ from playwright.sync_api import sync_playwright\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\n+ raise RuntimeError(\n+ \"playwright is required. Install with: pip install cli-anything-web-yu-pri\"\n+ ) from exc\n+\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\n+\n+ playwright = sync_playwright().start()\n+ context = None\n+ errors: list[str] = []\n+ channels = [browser_channel] if browser_channel else [\"msedge\", \"chrome\", None]\n+ try:\n+ for channel in channels:\n+ try:\n+ kwargs: dict[str, Any] = {\n+ \"headless\": headless,\n+ \"args\": [\"--disable-blink-features=AutomationControlled\"],\n+ }\n+ if channel:\n+ kwargs[\"channel\"] = channel\n+ context = playwright.chromium.launch_persistent_context(\n+ str(user_data_dir),\n+ **kwargs,\n+ )\n+ break\n+ except PlaywrightError as exc:\n+ label = channel or \"bundled-chromium\"\n+ errors.append(f\"{label}: {exc}\")\n+ if context is None:\n+ detail = \" | \".join(errors) if errors else \"no browser channels attempted\"\n+ raise RuntimeError(f\"could not launch Chromium/Edge browser: {detail}\")\n+\n+ page = context.pages[0] if context.pages else context.new_page()\n+ yield page, context\n+ finally:\n+ if context is not None:\n+ context.close()\n+ playwright.stop()\n+\n+\n+def open_login(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def inspect_url(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def capture_snapshot(\n+ url: str,\n+ output: str | Path,\n+ html_output: str | Path | None = None,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ output_path = Path(output).expanduser().resolve()\n+ output_path.parent.mkdir(parents=True, exist_ok=True)\n+ html_path = Path(html_output).expanduser().resolve() if html_output else None\n+ if html_path:\n+ html_path.parent.mkdir(parents=True, exist_ok=True)\n+\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ page.screenshot(path=str(output_path), full_page=True)\n+ if html_path:\n+ html_path.write_text(page.content(), encoding=\"utf-8\")\n+ info = inspect_page(page)\n+ info[\"screenshot\"] = str(output_path)\n+ if html_path:\n+ info[\"html\"] = str(html_path)\n+ return info\n+\n+\n+def inspect_page(page: Any) -> dict[str, Any]:\n+ \"\"\"Return cheap, JSON-safe page facts.\"\"\"\n+\n+ selector_presence = {\n+ name: page.locator(selector).count() > 0 for name, selector in SELECTORS.items()\n+ }\n+ return {\n+ \"url\": page.url,\n+ \"title\": page.title(),\n+ \"has_contents_form\": all(\n+ selector_presence[key]\n+ for key in (\"item_description\", \"item_value\", \"item_quantity\", \"total_value\")\n+ ),\n+ \"selectors\": selector_presence,\n+ }\n+\n+\n+def fill_contents(\n+ items: list[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+ url: str = CONTENTS_URL,\n+ profile_dir: str | Path | None = None,\n+ package_type: str | None = None,\n+ danger: bool | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+ delay_ms: int = 500,\n+) -> dict[str, Any]:\n+ \"\"\"Fill the known Web Yu-pri contents form and add each item line.\"\"\"\n+\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ _require_selector(page, SELECTORS[\"item_description\"])\n+","resolving_sha":"76ddd417358ce0ec35ab2ef06dee090442061e77","resolving_diff":"diff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\nnew file mode 100644\nindex 000000000..148ca168c\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\n@@ -0,0 +1,383 @@\n+\"\"\"Playwright backend for the real Web Yu-pri web application.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import time\n+from contextlib import contextmanager\n+from pathlib import Path\n+from typing import Any, Iterator\n+\n+from .items import ItemLine, build_contents_plan\n+\n+LOGIN_URL = \"https://mgr.post.japanpost.jp/C30P01Action.do\"\n+CONTENTS_URL = \"https://mgr.post.japanpost.jp/M060800.do\"\n+\n+SELECTORS = {\n+ \"item_description\": \"#M060800_itemBean_pkg\",\n+ \"item_value\": \"#M060800_itemBean_cost_value\",\n+ \"item_quantity\": \"#M060800_itemBean_num_value\",\n+ \"item_country\": \"#M060800_itemBean_couCd\",\n+ \"item_hs_code\": \"#M060800_itemBean_hsCode\",\n+ \"package_type\": \"#M060800_shippingBean_pkgType\",\n+ \"total_value\": \"#M060800_shippingBean_pkgTotalPrice_value\",\n+ \"danger\": \"#M060800_ShippingBean_danger\",\n+}\n+\n+ADD_ITEM_COMMAND = \"itemAdd2\"\n+\n+\n+def default_profile_dir() -> Path:\n+ return Path.home() / \".cli-anything-web-yu-pri\" / \"profile\"\n+\n+\n+def selector_report() -> dict[str, Any]:\n+ return {\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ }\n+\n+\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\n+ result: dict[str, Any] = {\n+ \"profile_dir\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\n+ \"login_url\": LOGIN_URL,\n+ \"contents_url\": CONTENTS_URL,\n+ \"playwright_available\": False,\n+ \"notes\": [],\n+ }\n+ try:\n+ import playwright # noqa: F401\n+\n+ result[\"playwright_available\"] = True\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\n+ result[\"notes\"].append(f\"playwright import failed: {exc}\")\n+ return result\n+\n+\n+@contextmanager\n+def browser_session(\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> Iterator[tuple[Any, Any]]:\n+ \"\"\"Launch a persistent browser context and yield (page, context).\"\"\"\n+\n+ try:\n+ from playwright.sync_api import Error as PlaywrightError\n+ from playwright.sync_api import sync_playwright\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\n+ raise RuntimeError(\n+ \"playwright is required. Install with: pip install cli-anything-web-yu-pri\"\n+ ) from exc\n+\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\n+\n+ playwright = sync_playwright().start()\n+ context = None\n+ errors: list[str] = []\n+ channels = [browser_channel] if browser_channel else [\"msedge\", \"chrome\", None]\n+ try:\n+ for channel in channels:\n+ try:\n+ kwargs: dict[str, Any] = {\n+ \"headless\": headless,\n+ \"args\": [\"--disable-blink-features=AutomationControlled\"],\n+ }\n+ if channel:\n+ kwargs[\"channel\"] = channel\n+ context = playwright.chromium.launch_persistent_context(\n+ str(user_data_dir),\n+ **kwargs,\n+ )\n+ break\n+ except PlaywrightError as exc:\n+ label = channel or \"bundled-chromium\"\n+ errors.append(f\"{label}: {exc}\")\n+ if context is None:\n+ detail = \" | \".join(errors) if errors else \"no browser channels attempted\"\n+ raise RuntimeError(f\"could not launch Chromium/Edge browser: {detail}\")\n+\n+ page = context.pages[0] if context.pages else context.new_page()\n+ yield page, context\n+ finally:\n+ if context is not None:\n+ context.close()\n+ playwright.stop()\n+\n+\n+def open_login(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def inspect_url(\n+ url: str = LOGIN_URL,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ return inspect_page(page)\n+\n+\n+def capture_snapshot(\n+ url: str,\n+ output: str | Path,\n+ html_output: str | Path | None = None,\n+ profile_dir: str | Path | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+) -> dict[str, Any]:\n+ output_path = Path(output).expanduser().resolve()\n+ output_path.parent.mkdir(parents=True, exist_ok=True)\n+ html_path = Path(html_output).expanduser().resolve() if html_output else None\n+ if html_path:\n+ html_path.parent.mkdir(parents=True, exist_ok=True)\n+\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ page.screenshot(path=str(output_path), full_page=True)\n+ if html_path:\n+ html_path.write_text(page.content(), encoding=\"utf-8\")\n+ info = inspect_page(page)\n+ info[\"screenshot\"] = str(output_path)\n+ if html_path:\n+ info[\"html\"] = str(html_path)\n+ return info\n+\n+\n+def inspect_page(page: Any) -> dict[str, Any]:\n+ \"\"\"Return cheap, JSON-safe page facts.\"\"\"\n+\n+ selector_presence = {\n+ name: page.locator(selector).count() > 0 for name, selector in SELECTORS.items()\n+ }\n+ return {\n+ \"url\": page.url,\n+ \"title\": page.title(),\n+ \"has_contents_form\": all(\n+ selector_presence[key]\n+ for key in (\"item_description\", \"item_value\", \"item_quantity\", \"total_value\")\n+ ),\n+ \"selectors\": selector_presence,\n+ }\n+\n+\n+def fill_contents(\n+ items: list[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+ url: str = CONTENTS_URL,\n+ profile_dir: str | Path | None = None,\n+ package_type: str | None = None,\n+ danger: bool | None = None,\n+ headless: bool = False,\n+ browser_channel: str | None = None,\n+ delay_ms: int = 500,\n+) -> dict[str, Any]:\n+ \"\"\"Fill the known Web Yu-pri contents form and add each item line.\"\"\"\n+\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\n+ page,\n+ _context,\n+ ):\n+ page.goto(url, wait_until=\"domcontentloaded\")\n+ _require_selector(page, SELECTORS[\"item_description\"])\n+\n+ if package_type:\n+ _set_value(page, SELECTORS[\"package_type\"], package_type)\n+ if danger is not None:\n+ _set_boolean(page, SELECTORS[\"danger\"], danger)\n+\n+ added: list[dict[str, Any]] = []\n+ for item in items:\n+ _fill_item(page, item)\n+ before = _body_fingerprint(page)\n+ _run_submit_command(page, ADD_ITEM_COMMAND)\n+ _wait_after_submit(page, before=before, delay_ms=delay_ms)\n+ added.append(\n+ {\n+ \"description\": item.description,\n+ \"value\": item.value,\n+ \"quantity\": item.quantity,\n+ \"country\": item.country,\n+ \"hs_code\": item.hs_code,\n+ }\n+ )\n+\n+ _set_value(page, SELECTORS[\"total_value\"], str(plan[\"declared_total\"]))\n+ info = inspect_page(page)\n+ verification = _verify_descriptions(page, [item.description for item in items])\n+ return {\n+ \"status\": \"filled\",\n+ \"plan\": plan,\n+ \"added\": added,\n+ \"page\": info,\n+ \"verification\": verification,\n+ \"safety\": {\n+ \"final_submit_clicked\": False,\n+ \"message\": \"Contents were filled only; final shipment confirmation is not clicked.\",\n+ },\n+ }\n+\n+\n+def build_dry_run(\n+ items: list[ItemLine],\n+ total_value: int | None = None,\n+ value_mode: str = \"line\",\n+ package_type: str | None = None,\n+ danger: bool | None = None,\n+) -> dict[str, Any]:\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\n+ return {\n+ \"dry_run\": True,\n+ \"plan\": plan,\n+ \"selectors\": SELECTORS,\n+ \"add_item_command\": ADD_ITEM_COMMAND,\n+ \"package_type\": package_type,\n+ \"danger\": danger,\n+ \"safety\": {\n+ \"browser_launched\": False,\n+ \"final_submit_clicked\": False,\n+ },\n+ }\n+\n+\n+def _fill_item(page: Any, item: ItemLine) -> None:\n+ _set_value(page, SELECTORS[\"item_description\"], item.description)\n+ _set_value(page, SELECTORS[\"item_value\"], str(item.value))\n+ _set_value(page, SELECTORS[\"item_quantity\"], str(item.quantity))\n+ if item.country:\n+ _set_value(page, SELECTORS[\"item_country\"], item.country)\n+ if item.hs_code:\n+ _set_value(page, SELECTORS[\"item_hs_code\"], item.hs_code)\n+\n+\n+def _require_selector(page: Any, selector: str, timeout_ms: int = 15_000) -> None:\n+ try:\n+ page.wait_for_selector(selector, timeout=timeout_ms)\n+ except Exception as exc:\n+ info = {\n+ \"url\": page.url,\n+ \"title\": page.title(),\n+ \"expected_selector\": selector,\n+ }\n+ raise RuntimeError(\n+ \"Web Yu-pri contents form was not found. \"\n+ f\"Page facts: {json.dumps(info, ensure_ascii=False)}\"\n+ ) from exc\n+\n+\n+def _set_value(page: Any, selector: str, value: str) -> None:\n+ locator = page.locator(selector)\n+ if locator.count() == 0:\n+ return\n+ try:\n+ tag_name = locator.first.evaluate(\"el => el.tagName.toLowerCase()\")\n+ if tag_name == \"select\":\n+ locator.first.select_option(value)\n+ else:\n+ locator.first.fill(str(value))\n+ except Exception:\n+ locator.first.evaluate(\n+ \"\"\"(el, value) => {\n+ el.value = value;\n+ el.dispatchEvent(new Event('input', {bubbles: true}));\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\n+ }\"\"\",\n+ str(value),\n+ )\n+\n+\n+def _set_boolean(page: Any, selector: str, value: bool) -> None:\n+ locator = page.locator(selector)\n+ if locator.count() == 0:\n+ return\n+ try:\n+ input_type = locator.first.evaluate(\"el => (el.type || '').toLowerCase()\")\n+ if input_type in {\"checkbox\", \"radio\"}:\n+ locator.first.set_checked(value)\n+ return\n+ except Exception:\n+ pass\n+ locator.first.evaluate(\n+ \"\"\"(el, value) => {\n+ el.checked = Boolean(value);\n+ el.value = value ? '1' : '';\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\n+ }\"\"\",\n+ value,\n+ )\n+\n+\n+def _run_submit_command(page: Any, command: str) -> None:\n+ page.evaluate(\n+ \"\"\"command => {\n+ if (typeof window.submitCommand === 'function') {\n+ window.submitCommand(command);\n+ return;\n+ }\n+ throw new Error('submitCommand is not available on this page');\n+ }\"\"\",\n+ command,\n+ )\n+\n+\n+def _wait_after_submit(page: Any, before: str, delay_ms: int) -> None:\n+ try:\n+ page.wait_for_load_state(\"domcontentloaded\", timeout=10_000)\n+ except Exception:\n+ pass\n+ deadline = time.time() + 10\n+ while time.time() < deadline:\n+ time.sleep(max(delay_ms, 100) / 1000)\n+ if _body_fingerprint(page) != before:\n+ return\n+\n+\n+def _body_fingerprint(page: Any) -> str:\n+ try:\n+ return page.evaluate(\n+ \"\"\"() => {\n+ const text = document.body ? document.body.innerText : '';\n+ const inputs = Array.from(document.querySelectorAll('input,select,textarea'))\n+ .slice(0, 200)\n+ .map(el => `${el.id || el.name || ''}:${el.value || ''}`)\n+ .join('|');\n+ return `${location.href}|${text.length}|${inputs.length}|${inputs}`;\n+ }\"\"\"\n+ )\n+ except Exception:\n+ return f\"{page.url}:{time.time()}\"\n+\n+\n+def _verify_descriptions(page: Any, descriptions: list[str]) -> dict[str, Any]:\n+ body_text = page.evaluate(\"() => document.body ? document.body.innerText : ''\")\n+ found = [description for description in descriptions if description in body_text]\n+ missing = [description for description in descriptions if description not in body_text]\n+ return {\n+ \"descriptions_found\": found,\n+ \"descriptions_missing\": missing,\n+ \"all_found\": not missing,\n+ }\n"},{"comment":"**<sub><sub></sub></sub> Move --json before Click subcommands in docs**\n\nThese quick-start commands place `--json` after the subcommand, but this CLI declares `--json` on the root Click group, so Click only accepts it before `plan`/`contents`; following these examples currently exits with `No such option: --json` instead of producing the documented JSON/dry-run output. The same bad examples are copied into the packaged README, so users installing the harness will hit this unless the examples are reordered as `cli-anything-web-yu-pri --json ...`.\n\nUseful? React with 👍 / 👎.","path":"web-yu-pri/agent-harness/README.md","hunk":"@@ -0,0 +1,71 @@\n+# cli-anything-web-yu-pri\n+\n+CLI harness for Japan Post Web Yu-pri label workflows.\n+\n+This CLI drives the real Web Yu-pri browser UI through Playwright. It uses a\n+persistent local browser profile so you can log in manually once, then run\n+structured commands for repetitive form entry. It does not store passwords and\n+does not click final shipment confirmation buttons.\n+\n+## Install\n+\n+```bash\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\n+```\n+\n+If Playwright cannot find a browser, install Microsoft Edge or Chrome, or run:\n+\n+```bash\n+python -m playwright install chromium\n+```\n+\n+## Quick Start\n+\n+```bash\n+cli-anything-web-yu-pri doctor\n+cli-anything-web-yu-pri open-login\n+cli-anything-web-yu-pri plan items.json --json\n+cli-anything-web-yu-pri contents fill items.json --dry-run --json\n+cli-anything-web-yu-pri contents fill items.json --json","resolving_sha":"76ddd417358ce0ec35ab2ef06dee090442061e77","resolving_diff":"diff --git a/web-yu-pri/agent-harness/README.md b/web-yu-pri/agent-harness/README.md\nnew file mode 100644\nindex 000000000..e22891683\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/README.md\n@@ -0,0 +1,71 @@\n+# cli-anything-web-yu-pri\n+\n+CLI harness for Japan Post Web Yu-pri label workflows.\n+\n+This CLI drives the real Web Yu-pri browser UI through Playwright. It uses a\n+persistent local browser profile so you can log in manually once, then run\n+structured commands for repetitive form entry. It does not store passwords and\n+does not click final shipment confirmation buttons.\n+\n+## Install\n+\n+```bash\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\n+```\n+\n+If Playwright cannot find a browser, install Microsoft Edge or Chrome, or run:\n+\n+```bash\n+python -m playwright install chromium\n+```\n+\n+## Quick Start\n+\n+```bash\n+cli-anything-web-yu-pri doctor\n+cli-anything-web-yu-pri open-login\n+cli-anything-web-yu-pri plan items.json --json\n+cli-anything-web-yu-pri contents fill items.json --dry-run --json\n+cli-anything-web-yu-pri contents fill items.json --json\n+```\n+\n+## Items File\n+\n+JSON:\n+\n+```json\n+{\n+ \"items\": [\n+ {\"description\": \"Award plaque\", \"value\": 8000, \"quantity\": 1, \"country\": \"KR\"},\n+ {\"description\": \"Certificate\", \"value\": 9000, \"quantity\": 1, \"country\": \"KR\"}\n+ ]\n+}\n+```\n+\n+CSV:\n+\n+```csv\n+description,value,quantity,country,hs_code\n+Award plaque,8000,1,KR,\n+Certificate,9000,1,KR,\n+```\n+\n+`value` is a line value by default. Add `--value-mode unit` when value should be\n+multiplied by quantity.\n+\n+## Commands\n+\n+| Command | Description |\n+| --- | --- |\n+| `doctor` | Check local runtime and profile paths |\n+| `selectors` | Print the known Web Yu-pri selector map |\n+| `plan <items-file>` | Validate JSON/CSV/TSV items and compute totals |\n+| `open-login` | Open the login/start URL in the persistent profile |\n+| `status` | Inspect title, URL, and selector presence |\n+| `snapshot -o page.png` | Capture screenshot and optional HTML |\n+| `contents fill <items-file>` | Fill contents rows and declared total |\n+\n+## Safety\n+\n+`contents fill` stops after filling contents and totals. It returns a `safety`\n+object in JSON output with `final_submit_clicked: false`.\n"}],"string":"[\n {\n \"comment\": \"**<sub><sub></sub></sub> Keep the login browser open for manual authentication**\\n\\nWhen a user runs `open-login` to establish the persistent profile, this function navigates to the login URL and then immediately exits the `with browser_session(...)` block, which closes the Playwright context in `finally`. In the documented quick-start/manual-login flow this leaves only a briefly flashing window, so users cannot actually complete the Japan Post login and save the session for later `status` or `contents fill` commands.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\",\n \"hunk\": \"@@ -0,0 +1,383 @@\\n+\\\"\\\"\\\"Playwright backend for the real Web Yu-pri web application.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import time\\n+from contextlib import contextmanager\\n+from pathlib import Path\\n+from typing import Any, Iterator\\n+\\n+from .items import ItemLine, build_contents_plan\\n+\\n+LOGIN_URL = \\\"https://mgr.post.japanpost.jp/C30P01Action.do\\\"\\n+CONTENTS_URL = \\\"https://mgr.post.japanpost.jp/M060800.do\\\"\\n+\\n+SELECTORS = {\\n+ \\\"item_description\\\": \\\"#M060800_itemBean_pkg\\\",\\n+ \\\"item_value\\\": \\\"#M060800_itemBean_cost_value\\\",\\n+ \\\"item_quantity\\\": \\\"#M060800_itemBean_num_value\\\",\\n+ \\\"item_country\\\": \\\"#M060800_itemBean_couCd\\\",\\n+ \\\"item_hs_code\\\": \\\"#M060800_itemBean_hsCode\\\",\\n+ \\\"package_type\\\": \\\"#M060800_shippingBean_pkgType\\\",\\n+ \\\"total_value\\\": \\\"#M060800_shippingBean_pkgTotalPrice_value\\\",\\n+ \\\"danger\\\": \\\"#M060800_ShippingBean_danger\\\",\\n+}\\n+\\n+ADD_ITEM_COMMAND = \\\"itemAdd2\\\"\\n+\\n+\\n+def default_profile_dir() -> Path:\\n+ return Path.home() / \\\".cli-anything-web-yu-pri\\\" / \\\"profile\\\"\\n+\\n+\\n+def selector_report() -> dict[str, Any]:\\n+ return {\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"selectors\\\": SELECTORS,\\n+ \\\"add_item_command\\\": ADD_ITEM_COMMAND,\\n+ }\\n+\\n+\\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\\n+ result: dict[str, Any] = {\\n+ \\\"profile_dir\\\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"playwright_available\\\": False,\\n+ \\\"notes\\\": [],\\n+ }\\n+ try:\\n+ import playwright # noqa: F401\\n+\\n+ result[\\\"playwright_available\\\"] = True\\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\\n+ result[\\\"notes\\\"].append(f\\\"playwright import failed: {exc}\\\")\\n+ return result\\n+\\n+\\n+@contextmanager\\n+def browser_session(\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> Iterator[tuple[Any, Any]]:\\n+ \\\"\\\"\\\"Launch a persistent browser context and yield (page, context).\\\"\\\"\\\"\\n+\\n+ try:\\n+ from playwright.sync_api import Error as PlaywrightError\\n+ from playwright.sync_api import sync_playwright\\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\\n+ raise RuntimeError(\\n+ \\\"playwright is required. Install with: pip install cli-anything-web-yu-pri\\\"\\n+ ) from exc\\n+\\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\\n+\\n+ playwright = sync_playwright().start()\\n+ context = None\\n+ errors: list[str] = []\\n+ channels = [browser_channel] if browser_channel else [\\\"msedge\\\", \\\"chrome\\\", None]\\n+ try:\\n+ for channel in channels:\\n+ try:\\n+ kwargs: dict[str, Any] = {\\n+ \\\"headless\\\": headless,\\n+ \\\"args\\\": [\\\"--disable-blink-features=AutomationControlled\\\"],\\n+ }\\n+ if channel:\\n+ kwargs[\\\"channel\\\"] = channel\\n+ context = playwright.chromium.launch_persistent_context(\\n+ str(user_data_dir),\\n+ **kwargs,\\n+ )\\n+ break\\n+ except PlaywrightError as exc:\\n+ label = channel or \\\"bundled-chromium\\\"\\n+ errors.append(f\\\"{label}: {exc}\\\")\\n+ if context is None:\\n+ detail = \\\" | \\\".join(errors) if errors else \\\"no browser channels attempted\\\"\\n+ raise RuntimeError(f\\\"could not launch Chromium/Edge browser: {detail}\\\")\\n+\\n+ page = context.pages[0] if context.pages else context.new_page()\\n+ yield page, context\\n+ finally:\\n+ if context is not None:\\n+ context.close()\\n+ playwright.stop()\\n+\\n+\\n+def open_login(\\n+ url: str = LOGIN_URL,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ return inspect_page(page)\",\n \"resolving_sha\": \"76ddd417358ce0ec35ab2ef06dee090442061e77\",\n \"resolving_diff\": \"diff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\\nnew file mode 100644\\nindex 000000000..148ca168c\\n--- /dev/null\\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\\n@@ -0,0 +1,383 @@\\n+\\\"\\\"\\\"Playwright backend for the real Web Yu-pri web application.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import time\\n+from contextlib import contextmanager\\n+from pathlib import Path\\n+from typing import Any, Iterator\\n+\\n+from .items import ItemLine, build_contents_plan\\n+\\n+LOGIN_URL = \\\"https://mgr.post.japanpost.jp/C30P01Action.do\\\"\\n+CONTENTS_URL = \\\"https://mgr.post.japanpost.jp/M060800.do\\\"\\n+\\n+SELECTORS = {\\n+ \\\"item_description\\\": \\\"#M060800_itemBean_pkg\\\",\\n+ \\\"item_value\\\": \\\"#M060800_itemBean_cost_value\\\",\\n+ \\\"item_quantity\\\": \\\"#M060800_itemBean_num_value\\\",\\n+ \\\"item_country\\\": \\\"#M060800_itemBean_couCd\\\",\\n+ \\\"item_hs_code\\\": \\\"#M060800_itemBean_hsCode\\\",\\n+ \\\"package_type\\\": \\\"#M060800_shippingBean_pkgType\\\",\\n+ \\\"total_value\\\": \\\"#M060800_shippingBean_pkgTotalPrice_value\\\",\\n+ \\\"danger\\\": \\\"#M060800_ShippingBean_danger\\\",\\n+}\\n+\\n+ADD_ITEM_COMMAND = \\\"itemAdd2\\\"\\n+\\n+\\n+def default_profile_dir() -> Path:\\n+ return Path.home() / \\\".cli-anything-web-yu-pri\\\" / \\\"profile\\\"\\n+\\n+\\n+def selector_report() -> dict[str, Any]:\\n+ return {\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"selectors\\\": SELECTORS,\\n+ \\\"add_item_command\\\": ADD_ITEM_COMMAND,\\n+ }\\n+\\n+\\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\\n+ result: dict[str, Any] = {\\n+ \\\"profile_dir\\\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"playwright_available\\\": False,\\n+ \\\"notes\\\": [],\\n+ }\\n+ try:\\n+ import playwright # noqa: F401\\n+\\n+ result[\\\"playwright_available\\\"] = True\\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\\n+ result[\\\"notes\\\"].append(f\\\"playwright import failed: {exc}\\\")\\n+ return result\\n+\\n+\\n+@contextmanager\\n+def browser_session(\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> Iterator[tuple[Any, Any]]:\\n+ \\\"\\\"\\\"Launch a persistent browser context and yield (page, context).\\\"\\\"\\\"\\n+\\n+ try:\\n+ from playwright.sync_api import Error as PlaywrightError\\n+ from playwright.sync_api import sync_playwright\\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\\n+ raise RuntimeError(\\n+ \\\"playwright is required. Install with: pip install cli-anything-web-yu-pri\\\"\\n+ ) from exc\\n+\\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\\n+\\n+ playwright = sync_playwright().start()\\n+ context = None\\n+ errors: list[str] = []\\n+ channels = [browser_channel] if browser_channel else [\\\"msedge\\\", \\\"chrome\\\", None]\\n+ try:\\n+ for channel in channels:\\n+ try:\\n+ kwargs: dict[str, Any] = {\\n+ \\\"headless\\\": headless,\\n+ \\\"args\\\": [\\\"--disable-blink-features=AutomationControlled\\\"],\\n+ }\\n+ if channel:\\n+ kwargs[\\\"channel\\\"] = channel\\n+ context = playwright.chromium.launch_persistent_context(\\n+ str(user_data_dir),\\n+ **kwargs,\\n+ )\\n+ break\\n+ except PlaywrightError as exc:\\n+ label = channel or \\\"bundled-chromium\\\"\\n+ errors.append(f\\\"{label}: {exc}\\\")\\n+ if context is None:\\n+ detail = \\\" | \\\".join(errors) if errors else \\\"no browser channels attempted\\\"\\n+ raise RuntimeError(f\\\"could not launch Chromium/Edge browser: {detail}\\\")\\n+\\n+ page = context.pages[0] if context.pages else context.new_page()\\n+ yield page, context\\n+ finally:\\n+ if context is not None:\\n+ context.close()\\n+ playwright.stop()\\n+\\n+\\n+def open_login(\\n+ url: str = LOGIN_URL,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ return inspect_page(page)\\n+\\n+\\n+def inspect_url(\\n+ url: str = LOGIN_URL,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ return inspect_page(page)\\n+\\n+\\n+def capture_snapshot(\\n+ url: str,\\n+ output: str | Path,\\n+ html_output: str | Path | None = None,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ output_path = Path(output).expanduser().resolve()\\n+ output_path.parent.mkdir(parents=True, exist_ok=True)\\n+ html_path = Path(html_output).expanduser().resolve() if html_output else None\\n+ if html_path:\\n+ html_path.parent.mkdir(parents=True, exist_ok=True)\\n+\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ page.screenshot(path=str(output_path), full_page=True)\\n+ if html_path:\\n+ html_path.write_text(page.content(), encoding=\\\"utf-8\\\")\\n+ info = inspect_page(page)\\n+ info[\\\"screenshot\\\"] = str(output_path)\\n+ if html_path:\\n+ info[\\\"html\\\"] = str(html_path)\\n+ return info\\n+\\n+\\n+def inspect_page(page: Any) -> dict[str, Any]:\\n+ \\\"\\\"\\\"Return cheap, JSON-safe page facts.\\\"\\\"\\\"\\n+\\n+ selector_presence = {\\n+ name: page.locator(selector).count() > 0 for name, selector in SELECTORS.items()\\n+ }\\n+ return {\\n+ \\\"url\\\": page.url,\\n+ \\\"title\\\": page.title(),\\n+ \\\"has_contents_form\\\": all(\\n+ selector_presence[key]\\n+ for key in (\\\"item_description\\\", \\\"item_value\\\", \\\"item_quantity\\\", \\\"total_value\\\")\\n+ ),\\n+ \\\"selectors\\\": selector_presence,\\n+ }\\n+\\n+\\n+def fill_contents(\\n+ items: list[ItemLine],\\n+ total_value: int | None = None,\\n+ value_mode: str = \\\"line\\\",\\n+ url: str = CONTENTS_URL,\\n+ profile_dir: str | Path | None = None,\\n+ package_type: str | None = None,\\n+ danger: bool | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+ delay_ms: int = 500,\\n+) -> dict[str, Any]:\\n+ \\\"\\\"\\\"Fill the known Web Yu-pri contents form and add each item line.\\\"\\\"\\\"\\n+\\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ _require_selector(page, SELECTORS[\\\"item_description\\\"])\\n+\\n+ if package_type:\\n+ _set_value(page, SELECTORS[\\\"package_type\\\"], package_type)\\n+ if danger is not None:\\n+ _set_boolean(page, SELECTORS[\\\"danger\\\"], danger)\\n+\\n+ added: list[dict[str, Any]] = []\\n+ for item in items:\\n+ _fill_item(page, item)\\n+ before = _body_fingerprint(page)\\n+ _run_submit_command(page, ADD_ITEM_COMMAND)\\n+ _wait_after_submit(page, before=before, delay_ms=delay_ms)\\n+ added.append(\\n+ {\\n+ \\\"description\\\": item.description,\\n+ \\\"value\\\": item.value,\\n+ \\\"quantity\\\": item.quantity,\\n+ \\\"country\\\": item.country,\\n+ \\\"hs_code\\\": item.hs_code,\\n+ }\\n+ )\\n+\\n+ _set_value(page, SELECTORS[\\\"total_value\\\"], str(plan[\\\"declared_total\\\"]))\\n+ info = inspect_page(page)\\n+ verification = _verify_descriptions(page, [item.description for item in items])\\n+ return {\\n+ \\\"status\\\": \\\"filled\\\",\\n+ \\\"plan\\\": plan,\\n+ \\\"added\\\": added,\\n+ \\\"page\\\": info,\\n+ \\\"verification\\\": verification,\\n+ \\\"safety\\\": {\\n+ \\\"final_submit_clicked\\\": False,\\n+ \\\"message\\\": \\\"Contents were filled only; final shipment confirmation is not clicked.\\\",\\n+ },\\n+ }\\n+\\n+\\n+def build_dry_run(\\n+ items: list[ItemLine],\\n+ total_value: int | None = None,\\n+ value_mode: str = \\\"line\\\",\\n+ package_type: str | None = None,\\n+ danger: bool | None = None,\\n+) -> dict[str, Any]:\\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\\n+ return {\\n+ \\\"dry_run\\\": True,\\n+ \\\"plan\\\": plan,\\n+ \\\"selectors\\\": SELECTORS,\\n+ \\\"add_item_command\\\": ADD_ITEM_COMMAND,\\n+ \\\"package_type\\\": package_type,\\n+ \\\"danger\\\": danger,\\n+ \\\"safety\\\": {\\n+ \\\"browser_launched\\\": False,\\n+ \\\"final_submit_clicked\\\": False,\\n+ },\\n+ }\\n+\\n+\\n+def _fill_item(page: Any, item: ItemLine) -> None:\\n+ _set_value(page, SELECTORS[\\\"item_description\\\"], item.description)\\n+ _set_value(page, SELECTORS[\\\"item_value\\\"], str(item.value))\\n+ _set_value(page, SELECTORS[\\\"item_quantity\\\"], str(item.quantity))\\n+ if item.country:\\n+ _set_value(page, SELECTORS[\\\"item_country\\\"], item.country)\\n+ if item.hs_code:\\n+ _set_value(page, SELECTORS[\\\"item_hs_code\\\"], item.hs_code)\\n+\\n+\\n+def _require_selector(page: Any, selector: str, timeout_ms: int = 15_000) -> None:\\n+ try:\\n+ page.wait_for_selector(selector, timeout=timeout_ms)\\n+ except Exception as exc:\\n+ info = {\\n+ \\\"url\\\": page.url,\\n+ \\\"title\\\": page.title(),\\n+ \\\"expected_selector\\\": selector,\\n+ }\\n+ raise RuntimeError(\\n+ \\\"Web Yu-pri contents form was not found. \\\"\\n+ f\\\"Page facts: {json.dumps(info, ensure_ascii=False)}\\\"\\n+ ) from exc\\n+\\n+\\n+def _set_value(page: Any, selector: str, value: str) -> None:\\n+ locator = page.locator(selector)\\n+ if locator.count() == 0:\\n+ return\\n+ try:\\n+ tag_name = locator.first.evaluate(\\\"el => el.tagName.toLowerCase()\\\")\\n+ if tag_name == \\\"select\\\":\\n+ locator.first.select_option(value)\\n+ else:\\n+ locator.first.fill(str(value))\\n+ except Exception:\\n+ locator.first.evaluate(\\n+ \\\"\\\"\\\"(el, value) => {\\n+ el.value = value;\\n+ el.dispatchEvent(new Event('input', {bubbles: true}));\\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\\n+ }\\\"\\\"\\\",\\n+ str(value),\\n+ )\\n+\\n+\\n+def _set_boolean(page: Any, selector: str, value: bool) -> None:\\n+ locator = page.locator(selector)\\n+ if locator.count() == 0:\\n+ return\\n+ try:\\n+ input_type = locator.first.evaluate(\\\"el => (el.type || '').toLowerCase()\\\")\\n+ if input_type in {\\\"checkbox\\\", \\\"radio\\\"}:\\n+ locator.first.set_checked(value)\\n+ return\\n+ except Exception:\\n+ pass\\n+ locator.first.evaluate(\\n+ \\\"\\\"\\\"(el, value) => {\\n+ el.checked = Boolean(value);\\n+ el.value = value ? '1' : '';\\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\\n+ }\\\"\\\"\\\",\\n+ value,\\n+ )\\n+\\n+\\n+def _run_submit_command(page: Any, command: str) -> None:\\n+ page.evaluate(\\n+ \\\"\\\"\\\"command => {\\n+ if (typeof window.submitCommand === 'function') {\\n+ window.submitCommand(command);\\n+ return;\\n+ }\\n+ throw new Error('submitCommand is not available on this page');\\n+ }\\\"\\\"\\\",\\n+ command,\\n+ )\\n+\\n+\\n+def _wait_after_submit(page: Any, before: str, delay_ms: int) -> None:\\n+ try:\\n+ page.wait_for_load_state(\\\"domcontentloaded\\\", timeout=10_000)\\n+ except Exception:\\n+ pass\\n+ deadline = time.time() + 10\\n+ while time.time() < deadline:\\n+ time.sleep(max(delay_ms, 100) / 1000)\\n+ if _body_fingerprint(page) != before:\\n+ return\\n+\\n+\\n+def _body_fingerprint(page: Any) -> str:\\n+ try:\\n+ return page.evaluate(\\n+ \\\"\\\"\\\"() => {\\n+ const text = document.body ? document.body.innerText : '';\\n+ const inputs = Array.from(document.querySelectorAll('input,select,textarea'))\\n+ .slice(0, 200)\\n+ .map(el => `${el.id || el.name || ''}:${el.value || ''}`)\\n+ .join('|');\\n+ return `${location.href}|${text.length}|${inputs.length}|${inputs}`;\\n+ }\\\"\\\"\\\"\\n+ )\\n+ except Exception:\\n+ return f\\\"{page.url}:{time.time()}\\\"\\n+\\n+\\n+def _verify_descriptions(page: Any, descriptions: list[str]) -> dict[str, Any]:\\n+ body_text = page.evaluate(\\\"() => document.body ? document.body.innerText : ''\\\")\\n+ found = [description for description in descriptions if description in body_text]\\n+ missing = [description for description in descriptions if description not in body_text]\\n+ return {\\n+ \\\"descriptions_found\\\": found,\\n+ \\\"descriptions_missing\\\": missing,\\n+ \\\"all_found\\\": not missing,\\n+ }\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Fail before submitting when required fields are absent**\\n\\nFor live `contents fill`, only the description selector is required before submitting each row; if the value, quantity, or total selectors are missing because Web Yu-pri changed the form or the user landed on a partial/wrong page, `_set_value` silently no-ops and the code still calls `submitCommand('itemAdd2')`. That can add incomplete or default-valued rows while reporting success, so the command should require all mandatory selectors before it starts submitting items.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\",\n \"hunk\": \"@@ -0,0 +1,383 @@\\n+\\\"\\\"\\\"Playwright backend for the real Web Yu-pri web application.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import time\\n+from contextlib import contextmanager\\n+from pathlib import Path\\n+from typing import Any, Iterator\\n+\\n+from .items import ItemLine, build_contents_plan\\n+\\n+LOGIN_URL = \\\"https://mgr.post.japanpost.jp/C30P01Action.do\\\"\\n+CONTENTS_URL = \\\"https://mgr.post.japanpost.jp/M060800.do\\\"\\n+\\n+SELECTORS = {\\n+ \\\"item_description\\\": \\\"#M060800_itemBean_pkg\\\",\\n+ \\\"item_value\\\": \\\"#M060800_itemBean_cost_value\\\",\\n+ \\\"item_quantity\\\": \\\"#M060800_itemBean_num_value\\\",\\n+ \\\"item_country\\\": \\\"#M060800_itemBean_couCd\\\",\\n+ \\\"item_hs_code\\\": \\\"#M060800_itemBean_hsCode\\\",\\n+ \\\"package_type\\\": \\\"#M060800_shippingBean_pkgType\\\",\\n+ \\\"total_value\\\": \\\"#M060800_shippingBean_pkgTotalPrice_value\\\",\\n+ \\\"danger\\\": \\\"#M060800_ShippingBean_danger\\\",\\n+}\\n+\\n+ADD_ITEM_COMMAND = \\\"itemAdd2\\\"\\n+\\n+\\n+def default_profile_dir() -> Path:\\n+ return Path.home() / \\\".cli-anything-web-yu-pri\\\" / \\\"profile\\\"\\n+\\n+\\n+def selector_report() -> dict[str, Any]:\\n+ return {\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"selectors\\\": SELECTORS,\\n+ \\\"add_item_command\\\": ADD_ITEM_COMMAND,\\n+ }\\n+\\n+\\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\\n+ result: dict[str, Any] = {\\n+ \\\"profile_dir\\\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"playwright_available\\\": False,\\n+ \\\"notes\\\": [],\\n+ }\\n+ try:\\n+ import playwright # noqa: F401\\n+\\n+ result[\\\"playwright_available\\\"] = True\\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\\n+ result[\\\"notes\\\"].append(f\\\"playwright import failed: {exc}\\\")\\n+ return result\\n+\\n+\\n+@contextmanager\\n+def browser_session(\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> Iterator[tuple[Any, Any]]:\\n+ \\\"\\\"\\\"Launch a persistent browser context and yield (page, context).\\\"\\\"\\\"\\n+\\n+ try:\\n+ from playwright.sync_api import Error as PlaywrightError\\n+ from playwright.sync_api import sync_playwright\\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\\n+ raise RuntimeError(\\n+ \\\"playwright is required. Install with: pip install cli-anything-web-yu-pri\\\"\\n+ ) from exc\\n+\\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\\n+\\n+ playwright = sync_playwright().start()\\n+ context = None\\n+ errors: list[str] = []\\n+ channels = [browser_channel] if browser_channel else [\\\"msedge\\\", \\\"chrome\\\", None]\\n+ try:\\n+ for channel in channels:\\n+ try:\\n+ kwargs: dict[str, Any] = {\\n+ \\\"headless\\\": headless,\\n+ \\\"args\\\": [\\\"--disable-blink-features=AutomationControlled\\\"],\\n+ }\\n+ if channel:\\n+ kwargs[\\\"channel\\\"] = channel\\n+ context = playwright.chromium.launch_persistent_context(\\n+ str(user_data_dir),\\n+ **kwargs,\\n+ )\\n+ break\\n+ except PlaywrightError as exc:\\n+ label = channel or \\\"bundled-chromium\\\"\\n+ errors.append(f\\\"{label}: {exc}\\\")\\n+ if context is None:\\n+ detail = \\\" | \\\".join(errors) if errors else \\\"no browser channels attempted\\\"\\n+ raise RuntimeError(f\\\"could not launch Chromium/Edge browser: {detail}\\\")\\n+\\n+ page = context.pages[0] if context.pages else context.new_page()\\n+ yield page, context\\n+ finally:\\n+ if context is not None:\\n+ context.close()\\n+ playwright.stop()\\n+\\n+\\n+def open_login(\\n+ url: str = LOGIN_URL,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ return inspect_page(page)\\n+\\n+\\n+def inspect_url(\\n+ url: str = LOGIN_URL,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ return inspect_page(page)\\n+\\n+\\n+def capture_snapshot(\\n+ url: str,\\n+ output: str | Path,\\n+ html_output: str | Path | None = None,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ output_path = Path(output).expanduser().resolve()\\n+ output_path.parent.mkdir(parents=True, exist_ok=True)\\n+ html_path = Path(html_output).expanduser().resolve() if html_output else None\\n+ if html_path:\\n+ html_path.parent.mkdir(parents=True, exist_ok=True)\\n+\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ page.screenshot(path=str(output_path), full_page=True)\\n+ if html_path:\\n+ html_path.write_text(page.content(), encoding=\\\"utf-8\\\")\\n+ info = inspect_page(page)\\n+ info[\\\"screenshot\\\"] = str(output_path)\\n+ if html_path:\\n+ info[\\\"html\\\"] = str(html_path)\\n+ return info\\n+\\n+\\n+def inspect_page(page: Any) -> dict[str, Any]:\\n+ \\\"\\\"\\\"Return cheap, JSON-safe page facts.\\\"\\\"\\\"\\n+\\n+ selector_presence = {\\n+ name: page.locator(selector).count() > 0 for name, selector in SELECTORS.items()\\n+ }\\n+ return {\\n+ \\\"url\\\": page.url,\\n+ \\\"title\\\": page.title(),\\n+ \\\"has_contents_form\\\": all(\\n+ selector_presence[key]\\n+ for key in (\\\"item_description\\\", \\\"item_value\\\", \\\"item_quantity\\\", \\\"total_value\\\")\\n+ ),\\n+ \\\"selectors\\\": selector_presence,\\n+ }\\n+\\n+\\n+def fill_contents(\\n+ items: list[ItemLine],\\n+ total_value: int | None = None,\\n+ value_mode: str = \\\"line\\\",\\n+ url: str = CONTENTS_URL,\\n+ profile_dir: str | Path | None = None,\\n+ package_type: str | None = None,\\n+ danger: bool | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+ delay_ms: int = 500,\\n+) -> dict[str, Any]:\\n+ \\\"\\\"\\\"Fill the known Web Yu-pri contents form and add each item line.\\\"\\\"\\\"\\n+\\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ _require_selector(page, SELECTORS[\\\"item_description\\\"])\\n+\",\n \"resolving_sha\": \"76ddd417358ce0ec35ab2ef06dee090442061e77\",\n \"resolving_diff\": \"diff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\\nnew file mode 100644\\nindex 000000000..148ca168c\\n--- /dev/null\\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/core/browser.py\\n@@ -0,0 +1,383 @@\\n+\\\"\\\"\\\"Playwright backend for the real Web Yu-pri web application.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import time\\n+from contextlib import contextmanager\\n+from pathlib import Path\\n+from typing import Any, Iterator\\n+\\n+from .items import ItemLine, build_contents_plan\\n+\\n+LOGIN_URL = \\\"https://mgr.post.japanpost.jp/C30P01Action.do\\\"\\n+CONTENTS_URL = \\\"https://mgr.post.japanpost.jp/M060800.do\\\"\\n+\\n+SELECTORS = {\\n+ \\\"item_description\\\": \\\"#M060800_itemBean_pkg\\\",\\n+ \\\"item_value\\\": \\\"#M060800_itemBean_cost_value\\\",\\n+ \\\"item_quantity\\\": \\\"#M060800_itemBean_num_value\\\",\\n+ \\\"item_country\\\": \\\"#M060800_itemBean_couCd\\\",\\n+ \\\"item_hs_code\\\": \\\"#M060800_itemBean_hsCode\\\",\\n+ \\\"package_type\\\": \\\"#M060800_shippingBean_pkgType\\\",\\n+ \\\"total_value\\\": \\\"#M060800_shippingBean_pkgTotalPrice_value\\\",\\n+ \\\"danger\\\": \\\"#M060800_ShippingBean_danger\\\",\\n+}\\n+\\n+ADD_ITEM_COMMAND = \\\"itemAdd2\\\"\\n+\\n+\\n+def default_profile_dir() -> Path:\\n+ return Path.home() / \\\".cli-anything-web-yu-pri\\\" / \\\"profile\\\"\\n+\\n+\\n+def selector_report() -> dict[str, Any]:\\n+ return {\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"selectors\\\": SELECTORS,\\n+ \\\"add_item_command\\\": ADD_ITEM_COMMAND,\\n+ }\\n+\\n+\\n+def doctor(profile_dir: str | Path | None = None) -> dict[str, Any]:\\n+ result: dict[str, Any] = {\\n+ \\\"profile_dir\\\": str(Path(profile_dir).expanduser() if profile_dir else default_profile_dir()),\\n+ \\\"login_url\\\": LOGIN_URL,\\n+ \\\"contents_url\\\": CONTENTS_URL,\\n+ \\\"playwright_available\\\": False,\\n+ \\\"notes\\\": [],\\n+ }\\n+ try:\\n+ import playwright # noqa: F401\\n+\\n+ result[\\\"playwright_available\\\"] = True\\n+ except Exception as exc: # pragma: no cover - depends on runtime environment\\n+ result[\\\"notes\\\"].append(f\\\"playwright import failed: {exc}\\\")\\n+ return result\\n+\\n+\\n+@contextmanager\\n+def browser_session(\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> Iterator[tuple[Any, Any]]:\\n+ \\\"\\\"\\\"Launch a persistent browser context and yield (page, context).\\\"\\\"\\\"\\n+\\n+ try:\\n+ from playwright.sync_api import Error as PlaywrightError\\n+ from playwright.sync_api import sync_playwright\\n+ except ImportError as exc: # pragma: no cover - dependency exercised via CLI doctor\\n+ raise RuntimeError(\\n+ \\\"playwright is required. Install with: pip install cli-anything-web-yu-pri\\\"\\n+ ) from exc\\n+\\n+ user_data_dir = Path(profile_dir).expanduser() if profile_dir else default_profile_dir()\\n+ user_data_dir.mkdir(parents=True, exist_ok=True)\\n+\\n+ playwright = sync_playwright().start()\\n+ context = None\\n+ errors: list[str] = []\\n+ channels = [browser_channel] if browser_channel else [\\\"msedge\\\", \\\"chrome\\\", None]\\n+ try:\\n+ for channel in channels:\\n+ try:\\n+ kwargs: dict[str, Any] = {\\n+ \\\"headless\\\": headless,\\n+ \\\"args\\\": [\\\"--disable-blink-features=AutomationControlled\\\"],\\n+ }\\n+ if channel:\\n+ kwargs[\\\"channel\\\"] = channel\\n+ context = playwright.chromium.launch_persistent_context(\\n+ str(user_data_dir),\\n+ **kwargs,\\n+ )\\n+ break\\n+ except PlaywrightError as exc:\\n+ label = channel or \\\"bundled-chromium\\\"\\n+ errors.append(f\\\"{label}: {exc}\\\")\\n+ if context is None:\\n+ detail = \\\" | \\\".join(errors) if errors else \\\"no browser channels attempted\\\"\\n+ raise RuntimeError(f\\\"could not launch Chromium/Edge browser: {detail}\\\")\\n+\\n+ page = context.pages[0] if context.pages else context.new_page()\\n+ yield page, context\\n+ finally:\\n+ if context is not None:\\n+ context.close()\\n+ playwright.stop()\\n+\\n+\\n+def open_login(\\n+ url: str = LOGIN_URL,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ return inspect_page(page)\\n+\\n+\\n+def inspect_url(\\n+ url: str = LOGIN_URL,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ return inspect_page(page)\\n+\\n+\\n+def capture_snapshot(\\n+ url: str,\\n+ output: str | Path,\\n+ html_output: str | Path | None = None,\\n+ profile_dir: str | Path | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+) -> dict[str, Any]:\\n+ output_path = Path(output).expanduser().resolve()\\n+ output_path.parent.mkdir(parents=True, exist_ok=True)\\n+ html_path = Path(html_output).expanduser().resolve() if html_output else None\\n+ if html_path:\\n+ html_path.parent.mkdir(parents=True, exist_ok=True)\\n+\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ page.screenshot(path=str(output_path), full_page=True)\\n+ if html_path:\\n+ html_path.write_text(page.content(), encoding=\\\"utf-8\\\")\\n+ info = inspect_page(page)\\n+ info[\\\"screenshot\\\"] = str(output_path)\\n+ if html_path:\\n+ info[\\\"html\\\"] = str(html_path)\\n+ return info\\n+\\n+\\n+def inspect_page(page: Any) -> dict[str, Any]:\\n+ \\\"\\\"\\\"Return cheap, JSON-safe page facts.\\\"\\\"\\\"\\n+\\n+ selector_presence = {\\n+ name: page.locator(selector).count() > 0 for name, selector in SELECTORS.items()\\n+ }\\n+ return {\\n+ \\\"url\\\": page.url,\\n+ \\\"title\\\": page.title(),\\n+ \\\"has_contents_form\\\": all(\\n+ selector_presence[key]\\n+ for key in (\\\"item_description\\\", \\\"item_value\\\", \\\"item_quantity\\\", \\\"total_value\\\")\\n+ ),\\n+ \\\"selectors\\\": selector_presence,\\n+ }\\n+\\n+\\n+def fill_contents(\\n+ items: list[ItemLine],\\n+ total_value: int | None = None,\\n+ value_mode: str = \\\"line\\\",\\n+ url: str = CONTENTS_URL,\\n+ profile_dir: str | Path | None = None,\\n+ package_type: str | None = None,\\n+ danger: bool | None = None,\\n+ headless: bool = False,\\n+ browser_channel: str | None = None,\\n+ delay_ms: int = 500,\\n+) -> dict[str, Any]:\\n+ \\\"\\\"\\\"Fill the known Web Yu-pri contents form and add each item line.\\\"\\\"\\\"\\n+\\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\\n+ with browser_session(profile_dir=profile_dir, headless=headless, browser_channel=browser_channel) as (\\n+ page,\\n+ _context,\\n+ ):\\n+ page.goto(url, wait_until=\\\"domcontentloaded\\\")\\n+ _require_selector(page, SELECTORS[\\\"item_description\\\"])\\n+\\n+ if package_type:\\n+ _set_value(page, SELECTORS[\\\"package_type\\\"], package_type)\\n+ if danger is not None:\\n+ _set_boolean(page, SELECTORS[\\\"danger\\\"], danger)\\n+\\n+ added: list[dict[str, Any]] = []\\n+ for item in items:\\n+ _fill_item(page, item)\\n+ before = _body_fingerprint(page)\\n+ _run_submit_command(page, ADD_ITEM_COMMAND)\\n+ _wait_after_submit(page, before=before, delay_ms=delay_ms)\\n+ added.append(\\n+ {\\n+ \\\"description\\\": item.description,\\n+ \\\"value\\\": item.value,\\n+ \\\"quantity\\\": item.quantity,\\n+ \\\"country\\\": item.country,\\n+ \\\"hs_code\\\": item.hs_code,\\n+ }\\n+ )\\n+\\n+ _set_value(page, SELECTORS[\\\"total_value\\\"], str(plan[\\\"declared_total\\\"]))\\n+ info = inspect_page(page)\\n+ verification = _verify_descriptions(page, [item.description for item in items])\\n+ return {\\n+ \\\"status\\\": \\\"filled\\\",\\n+ \\\"plan\\\": plan,\\n+ \\\"added\\\": added,\\n+ \\\"page\\\": info,\\n+ \\\"verification\\\": verification,\\n+ \\\"safety\\\": {\\n+ \\\"final_submit_clicked\\\": False,\\n+ \\\"message\\\": \\\"Contents were filled only; final shipment confirmation is not clicked.\\\",\\n+ },\\n+ }\\n+\\n+\\n+def build_dry_run(\\n+ items: list[ItemLine],\\n+ total_value: int | None = None,\\n+ value_mode: str = \\\"line\\\",\\n+ package_type: str | None = None,\\n+ danger: bool | None = None,\\n+) -> dict[str, Any]:\\n+ plan = build_contents_plan(items, total_value=total_value, value_mode=value_mode)\\n+ return {\\n+ \\\"dry_run\\\": True,\\n+ \\\"plan\\\": plan,\\n+ \\\"selectors\\\": SELECTORS,\\n+ \\\"add_item_command\\\": ADD_ITEM_COMMAND,\\n+ \\\"package_type\\\": package_type,\\n+ \\\"danger\\\": danger,\\n+ \\\"safety\\\": {\\n+ \\\"browser_launched\\\": False,\\n+ \\\"final_submit_clicked\\\": False,\\n+ },\\n+ }\\n+\\n+\\n+def _fill_item(page: Any, item: ItemLine) -> None:\\n+ _set_value(page, SELECTORS[\\\"item_description\\\"], item.description)\\n+ _set_value(page, SELECTORS[\\\"item_value\\\"], str(item.value))\\n+ _set_value(page, SELECTORS[\\\"item_quantity\\\"], str(item.quantity))\\n+ if item.country:\\n+ _set_value(page, SELECTORS[\\\"item_country\\\"], item.country)\\n+ if item.hs_code:\\n+ _set_value(page, SELECTORS[\\\"item_hs_code\\\"], item.hs_code)\\n+\\n+\\n+def _require_selector(page: Any, selector: str, timeout_ms: int = 15_000) -> None:\\n+ try:\\n+ page.wait_for_selector(selector, timeout=timeout_ms)\\n+ except Exception as exc:\\n+ info = {\\n+ \\\"url\\\": page.url,\\n+ \\\"title\\\": page.title(),\\n+ \\\"expected_selector\\\": selector,\\n+ }\\n+ raise RuntimeError(\\n+ \\\"Web Yu-pri contents form was not found. \\\"\\n+ f\\\"Page facts: {json.dumps(info, ensure_ascii=False)}\\\"\\n+ ) from exc\\n+\\n+\\n+def _set_value(page: Any, selector: str, value: str) -> None:\\n+ locator = page.locator(selector)\\n+ if locator.count() == 0:\\n+ return\\n+ try:\\n+ tag_name = locator.first.evaluate(\\\"el => el.tagName.toLowerCase()\\\")\\n+ if tag_name == \\\"select\\\":\\n+ locator.first.select_option(value)\\n+ else:\\n+ locator.first.fill(str(value))\\n+ except Exception:\\n+ locator.first.evaluate(\\n+ \\\"\\\"\\\"(el, value) => {\\n+ el.value = value;\\n+ el.dispatchEvent(new Event('input', {bubbles: true}));\\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\\n+ }\\\"\\\"\\\",\\n+ str(value),\\n+ )\\n+\\n+\\n+def _set_boolean(page: Any, selector: str, value: bool) -> None:\\n+ locator = page.locator(selector)\\n+ if locator.count() == 0:\\n+ return\\n+ try:\\n+ input_type = locator.first.evaluate(\\\"el => (el.type || '').toLowerCase()\\\")\\n+ if input_type in {\\\"checkbox\\\", \\\"radio\\\"}:\\n+ locator.first.set_checked(value)\\n+ return\\n+ except Exception:\\n+ pass\\n+ locator.first.evaluate(\\n+ \\\"\\\"\\\"(el, value) => {\\n+ el.checked = Boolean(value);\\n+ el.value = value ? '1' : '';\\n+ el.dispatchEvent(new Event('change', {bubbles: true}));\\n+ }\\\"\\\"\\\",\\n+ value,\\n+ )\\n+\\n+\\n+def _run_submit_command(page: Any, command: str) -> None:\\n+ page.evaluate(\\n+ \\\"\\\"\\\"command => {\\n+ if (typeof window.submitCommand === 'function') {\\n+ window.submitCommand(command);\\n+ return;\\n+ }\\n+ throw new Error('submitCommand is not available on this page');\\n+ }\\\"\\\"\\\",\\n+ command,\\n+ )\\n+\\n+\\n+def _wait_after_submit(page: Any, before: str, delay_ms: int) -> None:\\n+ try:\\n+ page.wait_for_load_state(\\\"domcontentloaded\\\", timeout=10_000)\\n+ except Exception:\\n+ pass\\n+ deadline = time.time() + 10\\n+ while time.time() < deadline:\\n+ time.sleep(max(delay_ms, 100) / 1000)\\n+ if _body_fingerprint(page) != before:\\n+ return\\n+\\n+\\n+def _body_fingerprint(page: Any) -> str:\\n+ try:\\n+ return page.evaluate(\\n+ \\\"\\\"\\\"() => {\\n+ const text = document.body ? document.body.innerText : '';\\n+ const inputs = Array.from(document.querySelectorAll('input,select,textarea'))\\n+ .slice(0, 200)\\n+ .map(el => `${el.id || el.name || ''}:${el.value || ''}`)\\n+ .join('|');\\n+ return `${location.href}|${text.length}|${inputs.length}|${inputs}`;\\n+ }\\\"\\\"\\\"\\n+ )\\n+ except Exception:\\n+ return f\\\"{page.url}:{time.time()}\\\"\\n+\\n+\\n+def _verify_descriptions(page: Any, descriptions: list[str]) -> dict[str, Any]:\\n+ body_text = page.evaluate(\\\"() => document.body ? document.body.innerText : ''\\\")\\n+ found = [description for description in descriptions if description in body_text]\\n+ missing = [description for description in descriptions if description not in body_text]\\n+ return {\\n+ \\\"descriptions_found\\\": found,\\n+ \\\"descriptions_missing\\\": missing,\\n+ \\\"all_found\\\": not missing,\\n+ }\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Move --json before Click subcommands in docs**\\n\\nThese quick-start commands place `--json` after the subcommand, but this CLI declares `--json` on the root Click group, so Click only accepts it before `plan`/`contents`; following these examples currently exits with `No such option: --json` instead of producing the documented JSON/dry-run output. The same bad examples are copied into the packaged README, so users installing the harness will hit this unless the examples are reordered as `cli-anything-web-yu-pri --json ...`.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"web-yu-pri/agent-harness/README.md\",\n \"hunk\": \"@@ -0,0 +1,71 @@\\n+# cli-anything-web-yu-pri\\n+\\n+CLI harness for Japan Post Web Yu-pri label workflows.\\n+\\n+This CLI drives the real Web Yu-pri browser UI through Playwright. It uses a\\n+persistent local browser profile so you can log in manually once, then run\\n+structured commands for repetitive form entry. It does not store passwords and\\n+does not click final shipment confirmation buttons.\\n+\\n+## Install\\n+\\n+```bash\\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\\n+```\\n+\\n+If Playwright cannot find a browser, install Microsoft Edge or Chrome, or run:\\n+\\n+```bash\\n+python -m playwright install chromium\\n+```\\n+\\n+## Quick Start\\n+\\n+```bash\\n+cli-anything-web-yu-pri doctor\\n+cli-anything-web-yu-pri open-login\\n+cli-anything-web-yu-pri plan items.json --json\\n+cli-anything-web-yu-pri contents fill items.json --dry-run --json\\n+cli-anything-web-yu-pri contents fill items.json --json\",\n \"resolving_sha\": \"76ddd417358ce0ec35ab2ef06dee090442061e77\",\n \"resolving_diff\": \"diff --git a/web-yu-pri/agent-harness/README.md b/web-yu-pri/agent-harness/README.md\\nnew file mode 100644\\nindex 000000000..e22891683\\n--- /dev/null\\n+++ b/web-yu-pri/agent-harness/README.md\\n@@ -0,0 +1,71 @@\\n+# cli-anything-web-yu-pri\\n+\\n+CLI harness for Japan Post Web Yu-pri label workflows.\\n+\\n+This CLI drives the real Web Yu-pri browser UI through Playwright. It uses a\\n+persistent local browser profile so you can log in manually once, then run\\n+structured commands for repetitive form entry. It does not store passwords and\\n+does not click final shipment confirmation buttons.\\n+\\n+## Install\\n+\\n+```bash\\n+pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=web-yu-pri/agent-harness\\n+```\\n+\\n+If Playwright cannot find a browser, install Microsoft Edge or Chrome, or run:\\n+\\n+```bash\\n+python -m playwright install chromium\\n+```\\n+\\n+## Quick Start\\n+\\n+```bash\\n+cli-anything-web-yu-pri doctor\\n+cli-anything-web-yu-pri open-login\\n+cli-anything-web-yu-pri plan items.json --json\\n+cli-anything-web-yu-pri contents fill items.json --dry-run --json\\n+cli-anything-web-yu-pri contents fill items.json --json\\n+```\\n+\\n+## Items File\\n+\\n+JSON:\\n+\\n+```json\\n+{\\n+ \\\"items\\\": [\\n+ {\\\"description\\\": \\\"Award plaque\\\", \\\"value\\\": 8000, \\\"quantity\\\": 1, \\\"country\\\": \\\"KR\\\"},\\n+ {\\\"description\\\": \\\"Certificate\\\", \\\"value\\\": 9000, \\\"quantity\\\": 1, \\\"country\\\": \\\"KR\\\"}\\n+ ]\\n+}\\n+```\\n+\\n+CSV:\\n+\\n+```csv\\n+description,value,quantity,country,hs_code\\n+Award plaque,8000,1,KR,\\n+Certificate,9000,1,KR,\\n+```\\n+\\n+`value` is a line value by default. Add `--value-mode unit` when value should be\\n+multiplied by quantity.\\n+\\n+## Commands\\n+\\n+| Command | Description |\\n+| --- | --- |\\n+| `doctor` | Check local runtime and profile paths |\\n+| `selectors` | Print the known Web Yu-pri selector map |\\n+| `plan <items-file>` | Validate JSON/CSV/TSV items and compute totals |\\n+| `open-login` | Open the login/start URL in the persistent profile |\\n+| `status` | Inspect title, URL, and selector presence |\\n+| `snapshot -o page.png` | Capture screenshot and optional HTML |\\n+| `contents fill <items-file>` | Fill contents rows and declared total |\\n+\\n+## Safety\\n+\\n+`contents fill` stops after filling contents and totals. It returns a `safety`\\n+object in JSON output with `final_submit_clicked: false`.\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":"diff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/TEST.md b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/TEST.md\nnew file mode 100644\nindex 000000000..a709bb2e1\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/TEST.md\n@@ -0,0 +1,101 @@\n+# Test Plan: cli-anything-web-yu-pri\n+\n+## Test Inventory Plan\n+\n+- `test_core.py`: 15 unit/CLI smoke tests planned.\n+- `test_full_e2e.py`: 2 E2E tests planned.\n+\n+## Unit Test Plan\n+\n+### `core.items`\n+\n+- JSON item loading from array and object payloads.\n+- CSV loading with aliases.\n+- Value parsing with commas and yen markers.\n+- Quantity validation.\n+- Country validation.\n+- Total computation in `line` and `unit` value modes.\n+- Declared total mismatch warning.\n+\n+### `core.browser`\n+\n+- Selector report returns the known Web Yu-pri form fields.\n+- Dry-run output includes safety metadata and does not launch a browser.\n+\n+### CLI\n+\n+- `--help` exits successfully.\n+- `plan --json` emits machine-readable totals.\n+- `contents fill --dry-run --json` emits browser-free dry-run output.\n+\n+## E2E Test Plan\n+\n+### Dry-run CLI workflow\n+\n+Simulates an agent validating a contents file before touching the real site.\n+Operations:\n+\n+1. Write a JSON item file.\n+2. Run `python -m cli_anything.web_yu_pri.web_yu_pri_cli --json contents fill ... --dry-run`.\n+3. Verify JSON structure, total, selector map, and safety metadata.\n+\n+### Optional live Web Yu-pri workflow\n+\n+Live execution requires a Japan Post account and a logged-in profile, so it is\n+gated by `WEB_YU_PRI_LIVE_E2E=1`. It runs `status` against the contents URL and\n+verifies the CLI can inspect the real page. Form mutation is intentionally not\n+part of default CI.\n+\n+## Test Results\n+\n+Command:\n+\n+```bash\n+python -m pytest cli_anything/web_yu_pri/tests -v\n+```\n+\n+Result:\n+\n+```text\n+collected 17 items\n+\n+cli_anything/web_yu_pri/tests/test_core.py::test_parse_item_mapping_aliases PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_parse_item_rejects_bad_country PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_load_json_object_payload PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_load_csv_aliases PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_plan_line_value_mode PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_plan_unit_value_mode PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_plan_warns_declared_total_mismatch PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_selector_report_contains_contents_controls PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_build_dry_run_has_safety_metadata PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_cli_help PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_cli_plan_json PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_cli_plan_missing_file_json PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_cli_contents_fill_dry_run_json PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_cli_contents_fill_missing_file_json PASSED\n+cli_anything/web_yu_pri/tests/test_core.py::test_cli_open_login_json_defaults_to_no_wait PASSED\n+cli_anything/web_yu_pri/tests/test_full_e2e.py::test_dry_run_cli_workflow PASSED\n+cli_anything/web_yu_pri/tests/test_full_e2e.py::test_live_status_against_contents_page SKIPPED\n+\n+16 passed, 1 skipped\n+```\n+\n+Additional checks:\n+\n+```text\n+python .github/scripts/validate_root_skills.py\n+Root skills validation passed.\n+\n+python -m json.tool registry.json\n+passed\n+\n+python -m build\n+passed\n+\n+python -m twine check dist/*\n+PASSED\n+```\n+\n+Coverage note: default tests do not log into Japan Post or mutate a real\n+shipment. The live status test is gated by `WEB_YU_PRI_LIVE_E2E=1` because it\n+requires a real account and persistent browser profile.\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/__init__.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/__init__.py\nnew file mode 100644\nindex 000000000..dce3a4085\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/__init__.py\n@@ -0,0 +1,1 @@\n+\"\"\"Tests for cli-anything-web-yu-pri.\"\"\"\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_core.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_core.py\nnew file mode 100644\nindex 000000000..bc7c11934\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_core.py\n@@ -0,0 +1,158 @@\n+\"\"\"Core tests for cli-anything-web-yu-pri.\"\"\"\n+\n+import json\n+from unittest.mock import patch\n+\n+from click.testing import CliRunner\n+import pytest\n+\n+from cli_anything.web_yu_pri.core.browser import ADD_ITEM_COMMAND, SELECTORS, build_dry_run, selector_report\n+from cli_anything.web_yu_pri.core.items import (\n+ ItemLine,\n+ build_contents_plan,\n+ load_items,\n+ parse_item_mapping,\n+)\n+from cli_anything.web_yu_pri.web_yu_pri_cli import cli\n+\n+\n+def test_parse_item_mapping_aliases():\n+ item = parse_item_mapping(\n+ {\n+ \"pkg\": \"Award plaque\",\n+ \"cost\": \"8,000\",\n+ \"num\": \"2\",\n+ \"couCd\": \"kr\",\n+ \"hsCode\": \"4901.99\",\n+ }\n+ )\n+ assert item.description == \"Award plaque\"\n+ assert item.value == 8000\n+ assert item.quantity == 2\n+ assert item.country == \"KR\"\n+ assert item.hs_code == \"4901.99\"\n+\n+\n+def test_parse_item_rejects_bad_country():\n+ with pytest.raises(ValueError, match=\"country\"):\n+ parse_item_mapping({\"description\": \"x\", \"value\": 1, \"country\": \"KOR\"})\n+\n+\n+def test_load_json_object_payload(tmp_path):\n+ path = tmp_path / \"items.json\"\n+ path.write_text(\n+ json.dumps({\"items\": [{\"description\": \"Certificate\", \"value\": 9000}]}),\n+ encoding=\"utf-8\",\n+ )\n+ items = load_items(path, default_country=\"KR\")\n+ assert items == [ItemLine(description=\"Certificate\", value=9000, quantity=1, country=\"KR\")]\n+\n+\n+def test_load_csv_aliases(tmp_path):\n+ path = tmp_path / \"items.csv\"\n+ path.write_text(\"name,amount,qty,origin\\nMedal,1000,3,US\\n\", encoding=\"utf-8\")\n+ items = load_items(path)\n+ assert items[0].description == \"Medal\"\n+ assert items[0].value == 1000\n+ assert items[0].quantity == 3\n+ assert items[0].country == \"US\"\n+\n+\n+def test_plan_line_value_mode():\n+ plan = build_contents_plan(\n+ [\n+ ItemLine(description=\"A\", value=8000, quantity=2),\n+ ItemLine(description=\"B\", value=9000, quantity=1),\n+ ],\n+ value_mode=\"line\",\n+ )\n+ assert plan[\"computed_total\"] == 17000\n+ assert plan[\"items\"][0][\"line_total\"] == 8000\n+\n+\n+def test_plan_unit_value_mode():\n+ plan = build_contents_plan(\n+ [\n+ ItemLine(description=\"A\", value=4000, quantity=2),\n+ ItemLine(description=\"B\", value=9000, quantity=1),\n+ ],\n+ value_mode=\"unit\",\n+ )\n+ assert plan[\"computed_total\"] == 17000\n+ assert plan[\"items\"][0][\"line_total\"] == 8000\n+\n+\n+def test_plan_warns_declared_total_mismatch():\n+ plan = build_contents_plan([ItemLine(description=\"A\", value=100)], total_value=200)\n+ assert plan[\"total_matches\"] is False\n+ assert plan[\"warnings\"]\n+\n+\n+def test_selector_report_contains_contents_controls():\n+ report = selector_report()\n+ assert report[\"selectors\"][\"item_description\"] == SELECTORS[\"item_description\"]\n+ assert report[\"add_item_command\"] == ADD_ITEM_COMMAND\n+\n+\n+def test_build_dry_run_has_safety_metadata():\n+ dry = build_dry_run([ItemLine(description=\"A\", value=100)])\n+ assert dry[\"dry_run\"] is True\n+ assert dry[\"safety\"][\"browser_launched\"] is False\n+ assert dry[\"safety\"][\"final_submit_clicked\"] is False\n+\n+\n+def test_cli_help():\n+ result = CliRunner().invoke(cli, [\"--help\"])\n+ assert result.exit_code == 0\n+ assert \"contents\" in result.output\n+\n+\n+def test_cli_plan_json(tmp_path):\n+ path = tmp_path / \"items.json\"\n+ path.write_text(json.dumps([{\"description\": \"A\", \"value\": 100}]), encoding=\"utf-8\")\n+ result = CliRunner().invoke(cli, [\"--json\", \"plan\", str(path)])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[\"computed_total\"] == 100\n+\n+\n+def test_cli_plan_missing_file_json(tmp_path):\n+ missing = tmp_path / \"missing.json\"\n+ result = CliRunner().invoke(cli, [\"--json\", \"plan\", str(missing)])\n+ assert result.exit_code == 1\n+ assert \"Usage:\" not in result.output\n+ data = json.loads(result.output)\n+ assert data[\"type\"] == \"FileNotFoundError\"\n+ assert \"items file not found\" in data[\"error\"]\n+\n+\n+def test_cli_contents_fill_dry_run_json(tmp_path):\n+ path = tmp_path / \"items.json\"\n+ path.write_text(json.dumps([{\"description\": \"A\", \"value\": 100}]), encoding=\"utf-8\")\n+ result = CliRunner().invoke(cli, [\"--json\", \"contents\", \"fill\", str(path), \"--dry-run\"])\n+ assert result.exit_code == 0\n+ data = json.loads(result.output)\n+ assert data[\"dry_run\"] is True\n+ assert data[\"plan\"][\"declared_total\"] == 100\n+\n+\n+def test_cli_contents_fill_missing_file_json(tmp_path):\n+ missing = tmp_path / \"missing.json\"\n+ result = CliRunner().invoke(cli, [\"--json\", \"contents\", \"fill\", str(missing), \"--dry-run\"])\n+ assert result.exit_code == 1\n+ assert \"Usage:\" not in result.output\n+ data = json.loads(result.output)\n+ assert data[\"type\"] == \"FileNotFoundError\"\n+ assert \"items file not found\" in data[\"error\"]\n+\n+\n+def test_cli_open_login_json_defaults_to_no_wait():\n+ fake_info = {\"url\": \"https://mgr.post.japanpost.jp/C30P01Action.do\", \"title\": \"Web Yu-pri\"}\n+ with patch(\"cli_anything.web_yu_pri.web_yu_pri_cli.open_login\", return_value=fake_info) as open_mock, \\\n+ patch(\"cli_anything.web_yu_pri.web_yu_pri_cli._interactive_session\") as interactive_mock:\n+ result = CliRunner().invoke(cli, [\"--json\", \"open-login\"])\n+\n+ assert result.exit_code == 0\n+ assert json.loads(result.output) == fake_info\n+ open_mock.assert_called_once()\n+ interactive_mock.assert_not_called()\ndiff --git a/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_full_e2e.py b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..b75cc37ca\n--- /dev/null\n+++ b/web-yu-pri/agent-harness/cli_anything/web_yu_pri/tests/test_full_e2e.py\n@@ -0,0 +1,45 @@\n+\"\"\"E2E tests for cli-anything-web-yu-pri.\"\"\"\n+\n+import json\n+import os\n+import subprocess\n+import sys\n+\n+import pytest\n+\n+\n+def _run_cli(args, check=True):\n+ command = [sys.executable, \"-m\", \"cli_anything.web_yu_pri.web_yu_pri_cli\"] + args\n+ return subprocess.run(command, capture_output=True, text=True, check=check)\n+\n+\n+def test_dry_run_cli_workflow(tmp_path):\n+ items_path = tmp_path / \"items.json\"\n+ items_path.write_text(\n+ json.dumps(\n+ {\n+ \"items\": [\n+ {\"description\": \"Award plaque\", \"value\": 8000, \"quantity\": 1, \"country\": \"KR\"},\n+ {\"description\": \"Certificate\", \"value\": 9000, \"quantity\": 1, \"country\": \"KR\"},\n+ ]\n+ }\n+ ),\n+ encoding=\"utf-8\",\n+ )\n+ result = _run_cli([\"--json\", \"contents\", \"fill\", str(items_path), \"--dry-run\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"dry_run\"] is True\n+ assert data[\"plan\"][\"computed_total\"] == 17000\n+ assert data[\"safety\"][\"final_submit_clicked\"] is False\n+ assert \"item_description\" in data[\"selectors\"]\n+\n+\n+@pytest.mark.skipif(\n+ os.environ.get(\"WEB_YU_PRI_LIVE_E2E\") != \"1\",\n+ reason=\"requires a real Japan Post account and logged-in browser profile\",\n+)\n+def test_live_status_against_contents_page():\n+ result = _run_cli([\"--json\", \"status\", \"--url\", \"https://mgr.post.japanpost.jp/M060800.do\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"url\"].startswith(\"https://mgr.post.japanpost.jp/\")\n+ assert \"title\" in data\n"},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4833,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":341,"string":"341"},"task_type":{"kind":"string","value":"issue_to_patch"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"feat: add OpenWebUI CLI registry entry"},"pr_body":{"kind":"string","value":"## Description\n\nAdds OpenWebUI to CLI-AnythingHub as a standalone repository CLI via `registry.json`.\n\nFixes: N/A\n\n## Type of Change\n\n- [ ] **New Software CLI (in-repo)** — adds a CLI harness inside this monorepo\n- [x] **New Software CLI (standalone repo)** — registry-only PR pointing to an external repo\n- [ ] **New Feature** — adds new functionality to an existing harness or the plugin\n- [ ] **Bug Fix** — fixes incorrect behavior\n- [ ] **Documentation** — updates docs only\n- [ ] **Other** — please describe:\n\n---\n\n### For New Software CLIs (in-repo)\n\n- [ ] `<SOFTWARE>.md` SOP document exists at `<software>/agent-harness/<SOFTWARE>.md`\n- [ ] Canonical `SKILL.md` exists at `skills/cli-anything-<software>/SKILL.md`\n- [ ] Packaged compatibility `SKILL.md` exists at `cli_anything/<software>/skills/SKILL.md`\n- [ ] Unit tests at `cli_anything/<software>/tests/test_core.py` are present and pass without backend\n- [ ] E2E tests at `cli_anything/<software>/tests/test_full_e2e.py` are present\n- [ ] `README.md` includes the new software (with link to harness directory)\n- [ ] `registry.json` includes an entry with `source_url: null` (see [Contributing guide](CONTRIBUTING.md#registry-fields))\n- [ ] `repl_skin.py` in `utils/` is an unmodified copy from the plugin\n\n### For New Software CLIs (standalone repo)\n\n- [x] CLI is installable via `pip install <package-name>` or a `pip install git+https://...` URL\n- [x] `SKILL.md` exists in the external repo\n- [x] External repo has its own test suite\n- [x] `registry.json` entry includes `source_url` pointing to the external repo\n- [x] `registry.json` entry includes `skill_md` with full URL to the external SKILL.md\n- [x] `install_cmd` in `registry.json` works (tested locally)\n\n### For Existing CLI Modifications\n\n- [ ] All unit tests pass: `python3 -m pytest cli_anything/<software>/tests/test_core.py -v`\n- [ ] All E2E tests pass: `python3 -m pytest cli_anything/<software>/tests/test_full_e2e.py -v`\n- [ ] No test regressions — no previously passing tests were removed or weakened\n- [ ] `registry.json` entry is updated if version, description, or requirements changed\n\n### General Checklist\n\n- [x] Code follows existing patterns and conventions\n- [x] `--json` flag is supported on any new commands\n- [x] Commit messages follow the conventional format (`feat:`, `fix:`, `docs:`, `test:`)\n- [x] I have tested my changes locally\n\n## Test Results\n\nRegistry validation:\n\n```text\nregistry ok\nopenwebui entry parsed successfully from registry.json\nno duplicate registry names\n```\n\nExternal CLI test suite:\n\n```text\npython -m pytest cli_anything\\openwebui\\tests -q\n............................... [100%]\n31 passed in 37.80s\n```\n\nInstall command validation in a fresh virtual environment:\n\n```text\npip install git+https://github.com/ashaiful/cli-anything-openwebui.git\nResolved https://github.com/ashaiful/cli-anything-openwebui.git to commit 5570c15849b43ceb20f1336b4afd5c04c8f6c924\nSuccessfully installed cli-anything-openwebui-1.0.0\ncli-anything-openwebui --help\ninstall_cmd ok\n```\n\nExternal repo CI:\n\n```text\nashaiful/cli-anything-openwebui CI completed successfully on main\n```\r\n"},"base_sha":{"kind":"string","value":"f23e051a053dfe34737f3d542f9fb3952d23922d"},"head_sha":{"kind":"string","value":"97269b17e5a5933e0d79dffebc2775164ce784f6"},"gold_diff":{"kind":"string","value":"diff --git a/registry.json b/registry.json\nindex 851cbafa1..bacc19aea 100644\n--- a/registry.json\n+++ b/registry.json\n@@ -450,6 +450,25 @@\n }\n ]\n },\n+ {\n+ \"name\": \"openwebui\",\n+ \"display_name\": \"OpenWebUI\",\n+ \"version\": \"1.0.0\",\n+ \"description\": \"Operate a running OpenWebUI backend through an agent-friendly CLI\",\n+ \"requires\": \"OpenWebUI instance running\",\n+ \"homepage\": \"https://openwebui.com\",\n+ \"source_url\": \"https://github.com/ashaiful/cli-anything-openwebui\",\n+ \"install_cmd\": \"pip install git+https://github.com/ashaiful/cli-anything-openwebui.git\",\n+ \"entry_point\": \"cli-anything-openwebui\",\n+ \"skill_md\": \"https://github.com/ashaiful/cli-anything-openwebui/blob/main/cli_anything/openwebui/skills/SKILL.md\",\n+ \"category\": \"ai\",\n+ \"contributors\": [\n+ {\n+ \"name\": \"ashaiful\",\n+ \"url\": \"https://github.com/ashaiful\"\n+ }\n+ ]\n+ },\n {\n \"name\": \"obs-studio\",\n \"display_name\": \"OBS Studio\",\n"},"changed_files":{"kind":"list like","value":["registry.json"],"string":"[\n \"registry.json\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[],"string":"[]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4834,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":332,"string":"332"},"task_type":{"kind":"string","value":"issue_to_patch"},"issue_text":{"kind":"string","value":"[Bug]: Codex skill installer omits the full methodology resources\n\n### Affected Software/Harness\n\nplugin\n\n### Version / Commit\n\ncommit 0cb261c11c24c74836bb83574e59338a4089e993\n\n### Operating System\n\nLinux\n\n### Python Version\n\n3.12.3\n\n### Steps to Reproduce\n\n1. Clone the repository:\n\n ```bash\n git clone https://github.com/HKUDS/CLI-Anything.git\n cd CLI-Anything\n\n 2. Install the bundled Codex skill:\n\n bash codex-skill/scripts/install.sh\n\n 3. Inspect the installed skill:\n\n find \"${CODEX_HOME:-$HOME/.codex}/skills/cli-anything\" -maxdepth 3 -type f | sort\n\n 4. Check the methodology path referenced by the installed SKILL.md:\n\n test -f \"${CODEX_HOME:-$HOME/.codex}/skills/cli-anything/../cli-anything-plugin/HARNESS.md\"\n echo $?\n\n 5. Observe that the installed skill references the full methodology, but the installer only copies codex-skill/.\n\n### Expected Behavior\n\n ```markdown\n The installed Codex skill should be self-contained.\n\n The installer should vendor the canonical resources required by the skill, including:\n\n - `HARNESS.md`\n - command specifications\n - on-demand guides\n - `repl_skin.py`\n - `preview_bundle.py`\n - `skill_generator.py`\n - `SKILL.md.template`\n - `docs/PREVIEW_PROTOCOL.md`\n\n Codex should be able to use the same full methodology as the Claude Code plugin after a normal installation.\n\n### Actual Behavior\n\nThe Codex installer only copies the `codex-skill/` directory.\n\n The installed `SKILL.md` instructs Codex to read:\n\n ```text\n ../cli-anything-plugin/HARNESS.md\n\n However, cli-anything-plugin/ is not installed next to the skill. The referenced HARNESS.md, guides, reusable scripts, templates, and preview protocol are\n unavailable.\n\n As a result, Codex falls back to a condensed 110-line summary instead of the complete Claude Code methodology.\n\n### Relevant Logs / Tracebacks\n\n```shell\n$ find \"${CODEX_HOME:-$HOME/.codex}/skills/cli-anything\" -maxdepth 3 -type f | sort\n /home/user/.codex/skills/cli-anything/SKILL.md\n /home/user/.codex/skills/cli-anything/agents/openai.yaml\n /home/user/.codex/skills/cli-anything/scripts/install.ps1\n /home/user/.codex/skills/cli-anything/scripts/install.sh\n\n $ test -f \"${CODEX_HOME:-$HOME/.codex}/skills/cli-anything/../cli-anything-plugin/HARNESS.md\"\n $ echo $?\n 1\n```\n\n### Additional Context\n\n The Pi Coding Agent extension already demonstrates a complete installation approach in:\n\n ```text\n .pi-extension/cli-anything/install.sh\n\n It copies the canonical methodology, commands, guides, templates, and reusable scripts from cli-anything-plugin/.\n\n I have prepared a fix that applies the same principle to the Codex installer while using Codex-native skill directories:\n\n - references/ for methodology documents\n - scripts/ for reusable helper code\n - assets/ for the skill template\n\n The fix also adds an installer regression test and a GitHub Actions workflow."},"pr_title":{"kind":"string","value":"fix: vendor full methodology resources for Codex skill"},"pr_body":{"kind":"string","value":"## Description\r\n\r\n Fix the Codex skill installation so it vendors the complete CLI-Anything methodology instead of installing only the condensed entry-point skill.\r\n\r\n Previously, the installed `SKILL.md` referenced `../cli-anything-plugin/HARNESS.md`, but the installer copied only `codex-skill/`. The referenced\r\n methodology, guides, helper scripts, templates, and preview protocol were therefore unavailable after a normal installation.\r\n\r\n This PR:\r\n\r\n - Vendors canonical resources from `cli-anything-plugin/` during Codex skill installation\r\n - Uses Codex-native `references/`, `scripts/`, and `assets/` directories\r\n - Adds full build, refine, test, validate, and list mode routing\r\n - Documents path remapping for vendored plugin resources\r\n - Keeps `cli-anything-plugin/` as the single source of truth\r\n - Adds an installer regression test with positive and negative cases\r\n - Adds a GitHub Actions workflow for Codex skill validation\r\n - Updates the English and Chinese README documentation\r\n\r\n Fixes #331\r\n\r\n ## Type of Change\r\n\r\n <!-- Check the one that applies: -->\r\n\r\n - [ ] **New Software CLI (in-repo)** — adds a CLI harness inside this monorepo\r\n - [ ] **New Software CLI (standalone repo)** — registry-only PR pointing to an external repo\r\n - [ ] **New Feature** — adds new functionality to an existing harness or the plugin\r\n - [x] **Bug Fix** — fixes incorrect behavior\r\n - [ ] **Documentation** — updates docs only\r\n - [ ] **Other** — please describe:\r\n\r\n ---\r\n\r\n ### For New Software CLIs (in-repo)\r\n\r\n <!-- Not applicable: this PR does not add a software CLI. -->\r\n\r\n - [ ] `<SOFTWARE>.md` SOP document exists at `<software>/agent-harness/<SOFTWARE>.md`\r\n - [ ] Canonical `SKILL.md` exists at `skills/cli-anything-<software>/SKILL.md`\r\n - [ ] Packaged compatibility `SKILL.md` exists at `cli_anything/<software>/skills/SKILL.md`\r\n - [ ] Unit tests at `cli_anything/<software>/tests/test_core.py` are present and pass without backend\r\n - [ ] E2E tests at `cli_anything/<software>/tests/test_full_e2e.py` are present\r\n - [ ] `README.md` includes the new software (with link to harness directory)\r\n - [ ] `registry.json` includes an entry with `source_url: null` (see [Contributing guide](CONTRIBUTING.md#registry-fields))\r\n - [ ] `repl_skin.py` in `utils/` is an unmodified copy from the plugin\r\n\r\n ### For New Software CLIs (standalone repo)\r\n\r\n <!-- Not applicable: this PR does not add a standalone CLI. -->\r\n\r\n - [ ] CLI is installable via `pip install <package-name>` or a `pip install git+https://...` URL\r\n - [ ] `SKILL.md` exists in the external repo\r\n - [ ] External repo has its own test suite\r\n - [ ] `registry.json` entry includes `source_url` pointing to the external repo\r\n - [ ] `registry.json` entry includes `skill_md` with full URL to the external SKILL.md\r\n - [ ] `install_cmd` in `registry.json` works (tested locally)\r\n\r\n ### For Existing CLI Modifications\r\n\r\n <!-- Not applicable: no existing software harness was modified. -->\r\n\r\n - [ ] All unit tests pass: `python3 -m pytest cli_anything/<software>/tests/test_core.py -v`\r\n - [ ] All E2E tests pass: `python3 -m pytest cli_anything/<software>/tests/test_full_e2e.py -v`\r\n - [x] No test regressions — no previously passing tests were removed or weakened\r\n - [ ] `registry.json` entry is updated if version, description, or requirements changed\r\n\r\n ### General Checklist\r\n\r\n - [x] Code follows existing patterns and conventions\r\n - [x] `--json` flag is supported on any new commands (N/A: no generated CLI commands were added)\r\n - [x] Commit messages follow the conventional format (`feat:`, `fix:`, `docs:`, `test:`)\r\n - [x] I have tested my changes locally\r\n\r\n ## Test Results\r\n\r\n ```text\r\n $ python3 ~/.codex/skills/.system/skill-creator/scripts/quick_validate.py codex-skill\r\n Skill is valid!\r\n\r\n $ bash codex-skill/tests/test_install.sh\r\n Installed Codex skill to: /tmp/.../codex-home/skills/cli-anything\r\n Vendored CLI-Anything methodology resources into the installed skill.\r\n Restart Codex to pick up the new skill.\r\n PASS: Codex skill installer vendors the complete CLI-Anything resource set.\r\n\r\n $ git diff --check\r\n # No output: passed\r\n\r\n $ bash -n codex-skill/scripts/install.sh codex-skill/tests/test_install.sh\r\n # No output: passed\r\n\r\n ## Additional Notes\r\n\r\n - The installer regression test verifies canonical resource mirroring, helper-script compilation, duplicate-install rejection, and clear failure behavior\r\n when codex-skill/ is detached from the full repository.\r\n - The PowerShell installer mirrors the Bash implementation but was not executed locally because PowerShell is unavailable in the current environment.\r\n - No software-specific harness was modified, so harness-level pytest runs are not applicable."},"base_sha":{"kind":"string","value":"f23e051a053dfe34737f3d542f9fb3952d23922d"},"head_sha":{"kind":"string","value":"96a4983e77439924765222dfd3103139627ae0c1"},"gold_diff":{"kind":"string","value":"diff --git a/.github/workflows/check-codex-skill.yml b/.github/workflows/check-codex-skill.yml\nnew file mode 100644\nindex 0000000000..829d02bbe7\n--- /dev/null\n+++ b/.github/workflows/check-codex-skill.yml\n@@ -0,0 +1,31 @@\n+name: Check Codex Skill\n+\n+on:\n+ pull_request:\n+ paths:\n+ - 'codex-skill/**'\n+ - 'cli-anything-plugin/**'\n+ - 'docs/PREVIEW_PROTOCOL.md'\n+ - '.github/workflows/check-codex-skill.yml'\n+ push:\n+ branches:\n+ - main\n+ paths:\n+ - 'codex-skill/**'\n+ - 'cli-anything-plugin/**'\n+ - 'docs/PREVIEW_PROTOCOL.md'\n+ - '.github/workflows/check-codex-skill.yml'\n+ workflow_dispatch:\n+\n+permissions:\n+ contents: read\n+\n+jobs:\n+ test-installer:\n+ runs-on: ubuntu-latest\n+ steps:\n+ - name: Check out repository\n+ uses: actions/checkout@v4\n+\n+ - name: Test Codex skill installer\n+ run: bash codex-skill/tests/test_install.sh\ndiff --git a/README.md b/README.md\nindex 9672f4ab2f..68fa899f00 100644\n--- a/README.md\n+++ b/README.md\n@@ -554,6 +554,11 @@ On Windows PowerShell, use:\n ```\n \n This installs the skill to `$CODEX_HOME/skills/cli-anything` (or `~/.codex/skills/cli-anything` if `CODEX_HOME` is unset).\n+The installer also vendors the canonical `HARNESS.md`, command specifications,\n+on-demand guides, reusable helper scripts, skill template, and preview protocol\n+into the installed skill's `references/` and `scripts/` directories.\n+This keeps the Codex skill self-contained while using `cli-anything-plugin/` as\n+the source of truth.\n \n Restart Codex after installation so it is discovered.\n \n@@ -565,10 +570,17 @@ Describe the task in natural language, for example:\n Use CLI-Anything to build a harness for ./gimp\n Use CLI-Anything to refine ./shotcut for picture-in-picture workflows\n Use CLI-Anything to validate ./libreoffice\n+Use CLI-Anything to list generated harnesses under the current directory\n ```\n \n The Codex skill adapts the same methodology used by the Claude Code plugin and\n OpenCode commands, while keeping the generated Python harness format unchanged.\n+\n+To verify the self-contained Codex installation locally:\n+\n+```bash\n+bash CLI-Anything/codex-skill/tests/test_install.sh\n+```\n </details>\n \n <details>\n@@ -1338,7 +1350,11 @@ cli-anything/\n │ └── scripts/\n │ └── setup-cli-anything.sh # Setup script\n │\n-├── 🤖 codex-skill/ # Codex skill entry point\n+├── 🤖 codex-skill/ # Self-contained Codex skill installer\n+│ ├── SKILL.md # Codex workflow entry point\n+│ ├── agents/ # Codex UI metadata\n+│ ├── scripts/ # Bash and PowerShell installers\n+│ └── tests/ # Installer resource-sync regression test\n ├── 🧭 hermes-skill/ # Hermes Agent skill entry point\n ├── 🎨 gimp/agent-harness/ # GIMP CLI (107 tests)\n ├── 🧊 blender/agent-harness/ # Blender CLI (208 tests)\ndiff --git a/README_CN.md b/README_CN.md\nindex 0f9502bd1b..b1ec17a454 100644\n--- a/README_CN.md\n+++ b/README_CN.md\n@@ -278,6 +278,7 @@ bash CLI-Anything/codex-skill/scripts/install.sh\n ```\n \n 脚本会把 skill 安装到 `$CODEX_HOME/skills/cli-anything`；如果没有设置 `CODEX_HOME`，则默认安装到 `~/.codex/skills/cli-anything`。\n+安装器还会把权威版本的 `HARNESS.md`、命令规范、按需指南、可复用辅助脚本、skill 模板和 preview 协议复制到已安装 skill 的 `references/` 和 `scripts/` 目录。这样 Codex skill 可以独立工作，同时仍以 `cli-anything-plugin/` 作为唯一权威来源。\n \n 安装后重启 Codex，让它重新发现这个 skill。\n \n@@ -289,11 +290,18 @@ bash CLI-Anything/codex-skill/scripts/install.sh\n Use CLI-Anything to build a harness for ./gimp\n Use CLI-Anything to refine ./shotcut for picture-in-picture workflows\n Use CLI-Anything to validate ./libreoffice\n+Use CLI-Anything to list generated harnesses under the current directory\n ```\n \n 这个 Codex skill 复用了 Claude Code 插件和 OpenCode 命令所使用的同一套方法论，\n 不会改变生成出来的 Python harness 结构。\n \n+可以运行下面的命令，验证 Codex 安装包是否完整：\n+\n+```bash\n+bash CLI-Anything/codex-skill/tests/test_install.sh\n+```\n+\n </details>\n \n <details>\n@@ -741,7 +749,11 @@ cli-anything/\n │ ├── cli-anything-validate.md # 标准验证\n │ └── cli-anything-list.md # 列出所有 CLI 工具\n │\n-├── 🤖 codex-skill/ # Codex skill 接入层\n+├── 🤖 codex-skill/ # 可独立安装的 Codex skill\n+│ ├── SKILL.md # Codex 工作流入口\n+│ ├── agents/ # Codex 界面元数据\n+│ ├── scripts/ # Bash 和 PowerShell 安装器\n+│ └── tests/ # 安装资源同步回归测试\n ├── 🎨 gimp/agent-harness/ # GIMP CLI（107 项测试）\n ├── 🧊 blender/agent-harness/ # Blender CLI（208 项测试）\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI（202 项测试）\ndiff --git a/codex-skill/SKILL.md b/codex-skill/SKILL.md\nindex 5d674e1603..c8f8ac1380 100644\n--- a/codex-skill/SKILL.md\n+++ b/codex-skill/SKILL.md\n@@ -1,13 +1,57 @@\n ---\n name: cli-anything\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\n ---\n \n # CLI-Anything for Codex\n \n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\n \n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\n+## Read the Full Methodology First\n+\n+Before implementation, use the full methodology source of truth:\n+\n+1. Read `references/HARNESS.md` relative to this skill directory.\n+2. Read the matching mode specification under `references/commands/`.\n+3. Read referenced files under `references/guides/` only when they apply to the target.\n+4. If the installed resources are unavailable and this skill is being used from a\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\n+ the resources around it.\n+5. If neither local source is available, clone or download\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\n+\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\n+skill so a normal Codex installation is self-contained.\n+\n+## Resource Map\n+\n+| Path | Purpose |\n+|------|---------|\n+| `references/HARNESS.md` | Complete methodology and quality rules |\n+| `references/commands/cli-anything.md` | Build-mode specification |\n+| `references/commands/refine.md` | Refine-mode specification |\n+| `references/commands/test.md` | Test-mode specification |\n+| `references/commands/validate.md` | Validation checklist |\n+| `references/commands/list.md` | Installed/generated harness discovery |\n+| `references/guides/` | On-demand implementation guidance |\n+| `scripts/repl_skin.py` | Copy into generated harnesses as `utils/repl_skin.py` |\n+| `scripts/preview_bundle.py` | Copy into preview-capable harnesses as `utils/preview_bundle.py` |\n+| `scripts/skill_generator.py` | Generate canonical and packaged CLI skills |\n+| `scripts/templates/SKILL.md.template` | Skill generation template used by `skill_generator.py` |\n+| `references/docs/PREVIEW_PROTOCOL.md` | Shared preview bundle protocol |\n+\n+When reading vendored documents, apply these path remappings instead of resolving\n+plugin paths against the current working directory:\n+\n+| Document reference | Installed skill path |\n+|--------------------|----------------------|\n+| `guides/...` | `references/guides/...` |\n+| `cli-anything-plugin/repl_skin.py` | `scripts/repl_skin.py` |\n+| `cli-anything-plugin/preview_bundle.py` | `scripts/preview_bundle.py` |\n+| `cli-anything-plugin/skill_generator.py` | `scripts/skill_generator.py` |\n+| `templates/SKILL.md.template` | `scripts/templates/SKILL.md.template` |\n+| `docs/PREVIEW_PROTOCOL.md` | `references/docs/PREVIEW_PROTOCOL.md` |\n \n ## Inputs\n \n@@ -22,9 +66,39 @@ Derive the software name from the local directory name after cloning if needed.\n \n ### Build\n \n-Use when the user wants a new harness.\n+Read `references/commands/cli-anything.md`. Build a complete harness through source\n+analysis, architecture design, implementation, test planning, test implementation,\n+test documentation, CLI-specific `SKILL.md` generation, and local installation.\n \n-Produce this structure:\n+### Refine\n+\n+Read `references/commands/refine.md`. Inventory current commands and tests, compare\n+them against the target software, then incrementally add high-impact capabilities\n+without removing existing commands unless the user requests a breaking change.\n+\n+### Test\n+\n+Read `references/commands/test.md`. Run the harness tests against the real backend,\n+verify installed-command subprocess coverage, and update `TEST.md` only with passing\n+results.\n+\n+### Validate\n+\n+Read `references/commands/validate.md`. Validate the harness against the complete\n+directory, implementation, test, documentation, packaging, and code-quality checklist.\n+\n+### List\n+\n+Read `references/commands/list.md`. Discover installed and generated CLI-Anything tools\n+and support human-readable or JSON output as requested.\n+\n+## Condensed Fallback Rules\n+\n+Use these only when the full methodology cannot be retrieved.\n+\n+### Harness Structure\n+\n+Produce:\n \n ```text\n <software>/\n@@ -42,63 +116,33 @@ Produce this structure:\n └── tests/\n ```\n \n-Implement a stateful Click CLI with:\n-\n-- one-shot subcommands\n-- REPL mode as the default when no subcommand is given\n-- `--json` machine-readable output\n-- session state with undo/redo where the target software supports it\n-\n-### Refine\n-\n-Use when the harness already exists.\n-\n-First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n-\n-- high-impact missing features\n-- easy wrappers around existing backend APIs or CLIs\n-- additions that compose well with existing commands\n-\n-Do not remove existing commands unless the user explicitly asks for a breaking change.\n-\n-### Test\n-\n-Plan tests before writing them. Keep both:\n-\n-- `test_core.py` for unit coverage\n-- `test_full_e2e.py` for workflow and backend validation\n-\n-When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n-\n-### Validate\n-\n-Check that the harness:\n-\n-- uses the `cli_anything.<software>` namespace package layout\n-- has an installable `setup.py` entry point\n-- supports JSON output\n-- has a REPL default path\n-- documents usage and tests\n-\n-## Backend Rules\n-\n-Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n-\n-## Packaging Rules\n-\n-- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n-- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n-- Expose `cli-anything-<software>` through `console_scripts`\n-\n-## Workflow\n-\n-1. Acquire the source tree locally.\n-2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n-3. Design command groups and state model.\n-4. Implement the harness.\n-5. Write `TEST.md`, then tests, then run them.\n-6. Update README usage docs.\n-7. Verify local installation with `pip install -e .`\n+### Required Behavior\n+\n+- Prefer the real software backend over reimplementation.\n+- Provide one-shot Click subcommands and default REPL mode.\n+- Support `--json` machine-readable output.\n+- Add session state with undo/redo where the target supports it.\n+- Auto-save one-shot session mutations and support `--dry-run`.\n+- Use locked session-file writes to avoid concurrent JSON corruption.\n+- Copy and use the unified `ReplSkin`.\n+- Add truthful preview commands for software with meaningful visual or inspection state.\n+- Generate both canonical and packaged CLI-specific `SKILL.md` files.\n+\n+### Testing\n+\n+- Write `TEST.md` before test code.\n+- Keep `test_core.py` for unit coverage.\n+- Keep `test_full_e2e.py` for real-file workflows and real backend validation.\n+- Verify rendered/exported output programmatically, not only process exit codes.\n+- Test the installed `cli-anything-<software>` command via `_resolve_cli()`.\n+- Run release validation with `CLI_ANYTHING_FORCE_INSTALLED=1`.\n+\n+### Packaging\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`.\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`.\n+- Expose `cli-anything-<software>` through `console_scripts`.\n+- Include the packaged CLI-specific `skills/SKILL.md`.\n \n ## Output Expectations\n \ndiff --git a/codex-skill/agents/openai.yaml b/codex-skill/agents/openai.yaml\nindex 7b0f71a602..0b87cbf287 100644\n--- a/codex-skill/agents/openai.yaml\n+++ b/codex-skill/agents/openai.yaml\n@@ -1,4 +1,4 @@\n interface:\n display_name: \"CLI-Anything\"\n- short_description: \"Build or refine CLI-Anything harnesses from Codex.\"\n- default_prompt: \"Use CLI-Anything to build, refine, test, or validate a harness for the user's target software or source repository.\"\n+ short_description: \"Build, refine, test, validate, or list harnesses.\"\n+ default_prompt: \"Use $cli-anything to build, refine, test, validate, or list harnesses for the user's target software or source repository.\"\ndiff --git a/codex-skill/scripts/install.ps1 b/codex-skill/scripts/install.ps1\nindex ac58bd2134..a2e932748c 100644\n--- a/codex-skill/scripts/install.ps1\n+++ b/codex-skill/scripts/install.ps1\n@@ -2,6 +2,9 @@ $ErrorActionPreference = \"Stop\"\n \n $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path\n $skillDir = Split-Path -Parent $scriptDir\n+$repoRoot = Split-Path -Parent $skillDir\n+$pluginDir = Join-Path $repoRoot \"cli-anything-plugin\"\n+$previewProtocol = Join-Path $repoRoot \"docs/PREVIEW_PROTOCOL.md\"\n \n $codexHome = if ($env:CODEX_HOME) {\n $env:CODEX_HOME\n@@ -13,14 +16,52 @@ $codexHome = if ($env:CODEX_HOME) {\n \n $destRoot = Join-Path $codexHome \"skills\"\n $destDir = Join-Path $destRoot \"cli-anything\"\n+$stagingDir = $null\n+\n+if (-not (Test-Path (Join-Path $pluginDir \"HARNESS.md\"))) {\n+ throw \"Cannot find canonical CLI-Anything resources at: $pluginDir`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n+\n+if (-not (Test-Path $previewProtocol)) {\n+ throw \"Cannot find preview protocol at: $previewProtocol`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n \n New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\n \n if (Test-Path $destDir) {\n- Write-Error \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n+ throw \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n }\n \n-Copy-Item -Path $skillDir -Destination $destDir -Recurse\n+try {\n+ $stagingDir = Join-Path $destRoot (\".cli-anything.tmp.\" + [System.Guid]::NewGuid().ToString(\"N\"))\n+ New-Item -ItemType Directory -Path $stagingDir | Out-Null\n+ Get-ChildItem -LiteralPath $skillDir -Force | Copy-Item -Destination $stagingDir -Recurse -Force\n+\n+ $referenceDir = Join-Path $stagingDir \"references\"\n+ $referenceCommands = Join-Path $referenceDir \"commands\"\n+ $referenceDocs = Join-Path $referenceDir \"docs\"\n+ $referenceGuides = Join-Path $referenceDir \"guides\"\n+ $resourceScripts = Join-Path $stagingDir \"scripts\"\n+ $scriptTemplates = Join-Path $resourceScripts \"templates\"\n+\n+ New-Item -ItemType Directory -Path $referenceCommands, $referenceDocs, $referenceGuides, $scriptTemplates -Force | Out-Null\n+\n+ Copy-Item -Path (Join-Path $pluginDir \"HARNESS.md\") -Destination (Join-Path $referenceDir \"HARNESS.md\")\n+ Copy-Item -Path (Join-Path $pluginDir \"commands/*.md\") -Destination $referenceCommands\n+ Copy-Item -Path (Join-Path $pluginDir \"guides/*.md\") -Destination $referenceGuides\n+ Copy-Item -Path (Join-Path $pluginDir \"repl_skin.py\") -Destination (Join-Path $resourceScripts \"repl_skin.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"preview_bundle.py\") -Destination (Join-Path $resourceScripts \"preview_bundle.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"skill_generator.py\") -Destination (Join-Path $resourceScripts \"skill_generator.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"templates/*\") -Destination $scriptTemplates\n+ Copy-Item -Path $previewProtocol -Destination (Join-Path $referenceDocs \"PREVIEW_PROTOCOL.md\")\n+\n+ Move-Item -Path $stagingDir -Destination $destDir\n+} finally {\n+ if ($stagingDir -and (Test-Path $stagingDir)) {\n+ Remove-Item -Path $stagingDir -Recurse -Force\n+ }\n+}\n \n Write-Host \"Installed Codex skill to: $destDir\"\n+Write-Host \"Vendored CLI-Anything methodology resources into the installed skill.\"\n Write-Host \"Restart Codex to pick up the new skill.\"\ndiff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\nindex aa14514d8c..0646e3f460 100755\n--- a/codex-skill/scripts/install.sh\n+++ b/codex-skill/scripts/install.sh\n@@ -4,8 +4,24 @@ set -euo pipefail\n \n SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+PREVIEW_PROTOCOL=\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\"\n DEST_ROOT=\"${CODEX_HOME:-$HOME/.codex}/skills\"\n DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+STAGING_DIR=\"\"\n+\n+if [[ ! -f \"${PLUGIN_DIR}/HARNESS.md\" ]]; then\n+ echo \"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n+\n+if [[ ! -f \"${PREVIEW_PROTOCOL}\" ]]; then\n+ echo \"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n \n mkdir -p \"${DEST_ROOT}\"\n \n@@ -15,7 +31,32 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ if [[ -n \"${STAGING_DIR}\" && -d \"${STAGING_DIR}\" ]]; then\n+ rm -rf \"${STAGING_DIR}\"\n+ fi\n+}\n+trap cleanup EXIT\n+\n+STAGING_DIR=\"$(mktemp -d \"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\")\"\n+cp -R \"${SKILL_DIR}/.\" \"${STAGING_DIR}/\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts/templates\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/scripts/templates/\"\n+cp \"${PREVIEW_PROTOCOL}\" \"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+\n+mv \"${STAGING_DIR}\" \"${DEST_DIR}\"\n \n echo \"Installed Codex skill to: ${DEST_DIR}\"\n+echo \"Vendored CLI-Anything methodology resources into the installed skill.\"\n echo \"Restart Codex to pick up the new skill.\"\n"},"changed_files":{"kind":"list like","value":[".github/workflows/check-codex-skill.yml","README.md","README_CN.md","codex-skill/SKILL.md","codex-skill/agents/openai.yaml","codex-skill/scripts/install.ps1","codex-skill/scripts/install.sh","codex-skill/tests/test_install.sh"],"string":"[\n \".github/workflows/check-codex-skill.yml\",\n \"README.md\",\n \"README_CN.md\",\n \"codex-skill/SKILL.md\",\n \"codex-skill/agents/openai.yaml\",\n \"codex-skill/scripts/install.ps1\",\n \"codex-skill/scripts/install.sh\",\n \"codex-skill/tests/test_install.sh\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"`cp -R \"${SKILL_DIR}\" \"${STAGING_DIR}\"` behaves differently if `${STAGING_DIR}` already exists (it will copy the skill into a nested subdirectory), which can produce a broken install layout. Since `${STAGING_DIR}` is a predictable name, it can be left behind from a prior crash or collide with a concurrent run. Use a guaranteed-unique temp dir (e.g., `mktemp -d` under `${DEST_ROOT}`) and/or explicitly remove/abort when `${STAGING_DIR}` exists before copying.","path":"codex-skill/scripts/install.sh","hunk":"@@ -4,8 +4,24 @@ set -euo pipefail\n \n SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+PREVIEW_PROTOCOL=\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\"\n DEST_ROOT=\"${CODEX_HOME:-$HOME/.codex}/skills\"\n DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+STAGING_DIR=\"${DEST_ROOT}/.cli-anything.tmp.$$\"","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\nindex aa14514d8c..0646e3f460 100755\n--- a/codex-skill/scripts/install.sh\n+++ b/codex-skill/scripts/install.sh\n@@ -4,8 +4,24 @@ set -euo pipefail\n \n SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+PREVIEW_PROTOCOL=\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\"\n DEST_ROOT=\"${CODEX_HOME:-$HOME/.codex}/skills\"\n DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+STAGING_DIR=\"\"\n+\n+if [[ ! -f \"${PLUGIN_DIR}/HARNESS.md\" ]]; then\n+ echo \"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n+\n+if [[ ! -f \"${PREVIEW_PROTOCOL}\" ]]; then\n+ echo \"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n \n mkdir -p \"${DEST_ROOT}\"\n \n@@ -15,7 +31,32 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ if [[ -n \"${STAGING_DIR}\" && -d \"${STAGING_DIR}\" ]]; then\n+ rm -rf \"${STAGING_DIR}\"\n+ fi\n+}\n+trap cleanup EXIT\n+\n+STAGING_DIR=\"$(mktemp -d \"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\")\"\n+cp -R \"${SKILL_DIR}/.\" \"${STAGING_DIR}/\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts/templates\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/scripts/templates/\"\n+cp \"${PREVIEW_PROTOCOL}\" \"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+\n+mv \"${STAGING_DIR}\" \"${DEST_DIR}\"\n \n echo \"Installed Codex skill to: ${DEST_DIR}\"\n+echo \"Vendored CLI-Anything methodology resources into the installed skill.\"\n echo \"Restart Codex to pick up the new skill.\"\n"},{"comment":"`cp -R \"${SKILL_DIR}\" \"${STAGING_DIR}\"` behaves differently if `${STAGING_DIR}` already exists (it will copy the skill into a nested subdirectory), which can produce a broken install layout. Since `${STAGING_DIR}` is a predictable name, it can be left behind from a prior crash or collide with a concurrent run. Use a guaranteed-unique temp dir (e.g., `mktemp -d` under `${DEST_ROOT}`) and/or explicitly remove/abort when `${STAGING_DIR}` exists before copying.","path":"codex-skill/scripts/install.sh","hunk":"@@ -15,7 +31,30 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ rm -rf \"${STAGING_DIR}\"\n+}\n+trap cleanup EXIT\n+\n+cp -R \"${SKILL_DIR}\" \"${STAGING_DIR}\"","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\nindex aa14514d8c..0646e3f460 100755\n--- a/codex-skill/scripts/install.sh\n+++ b/codex-skill/scripts/install.sh\n@@ -4,8 +4,24 @@ set -euo pipefail\n \n SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+PREVIEW_PROTOCOL=\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\"\n DEST_ROOT=\"${CODEX_HOME:-$HOME/.codex}/skills\"\n DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+STAGING_DIR=\"\"\n+\n+if [[ ! -f \"${PLUGIN_DIR}/HARNESS.md\" ]]; then\n+ echo \"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n+\n+if [[ ! -f \"${PREVIEW_PROTOCOL}\" ]]; then\n+ echo \"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n \n mkdir -p \"${DEST_ROOT}\"\n \n@@ -15,7 +31,32 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ if [[ -n \"${STAGING_DIR}\" && -d \"${STAGING_DIR}\" ]]; then\n+ rm -rf \"${STAGING_DIR}\"\n+ fi\n+}\n+trap cleanup EXIT\n+\n+STAGING_DIR=\"$(mktemp -d \"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\")\"\n+cp -R \"${SKILL_DIR}/.\" \"${STAGING_DIR}/\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts/templates\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/scripts/templates/\"\n+cp \"${PREVIEW_PROTOCOL}\" \"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+\n+mv \"${STAGING_DIR}\" \"${DEST_DIR}\"\n \n echo \"Installed Codex skill to: ${DEST_DIR}\"\n+echo \"Vendored CLI-Anything methodology resources into the installed skill.\"\n echo \"Restart Codex to pick up the new skill.\"\n"},{"comment":"Similar to the Bash installer, `Copy-Item` will copy *into* an existing `$stagingDir` (creating an extra nesting level) rather than producing the expected staged layout. Because `$stagingDir` is deterministic per PID/session, it can exist from a previous interrupted run. Consider using a random/unique staging directory name (or creating it first and throwing if it exists), and ensure any pre-existing path is removed before the copy to prevent malformed installs.","path":"codex-skill/scripts/install.ps1","hunk":"@@ -13,14 +16,50 @@ $codexHome = if ($env:CODEX_HOME) {\n \n $destRoot = Join-Path $codexHome \"skills\"\n $destDir = Join-Path $destRoot \"cli-anything\"\n+$stagingDir = Join-Path $destRoot \".cli-anything.tmp.$PID\"","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/scripts/install.ps1 b/codex-skill/scripts/install.ps1\nindex ac58bd2134..a2e932748c 100644\n--- a/codex-skill/scripts/install.ps1\n+++ b/codex-skill/scripts/install.ps1\n@@ -2,6 +2,9 @@ $ErrorActionPreference = \"Stop\"\n \n $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path\n $skillDir = Split-Path -Parent $scriptDir\n+$repoRoot = Split-Path -Parent $skillDir\n+$pluginDir = Join-Path $repoRoot \"cli-anything-plugin\"\n+$previewProtocol = Join-Path $repoRoot \"docs/PREVIEW_PROTOCOL.md\"\n \n $codexHome = if ($env:CODEX_HOME) {\n $env:CODEX_HOME\n@@ -13,14 +16,52 @@ $codexHome = if ($env:CODEX_HOME) {\n \n $destRoot = Join-Path $codexHome \"skills\"\n $destDir = Join-Path $destRoot \"cli-anything\"\n+$stagingDir = $null\n+\n+if (-not (Test-Path (Join-Path $pluginDir \"HARNESS.md\"))) {\n+ throw \"Cannot find canonical CLI-Anything resources at: $pluginDir`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n+\n+if (-not (Test-Path $previewProtocol)) {\n+ throw \"Cannot find preview protocol at: $previewProtocol`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n \n New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\n \n if (Test-Path $destDir) {\n- Write-Error \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n+ throw \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n }\n \n-Copy-Item -Path $skillDir -Destination $destDir -Recurse\n+try {\n+ $stagingDir = Join-Path $destRoot (\".cli-anything.tmp.\" + [System.Guid]::NewGuid().ToString(\"N\"))\n+ New-Item -ItemType Directory -Path $stagingDir | Out-Null\n+ Get-ChildItem -LiteralPath $skillDir -Force | Copy-Item -Destination $stagingDir -Recurse -Force\n+\n+ $referenceDir = Join-Path $stagingDir \"references\"\n+ $referenceCommands = Join-Path $referenceDir \"commands\"\n+ $referenceDocs = Join-Path $referenceDir \"docs\"\n+ $referenceGuides = Join-Path $referenceDir \"guides\"\n+ $resourceScripts = Join-Path $stagingDir \"scripts\"\n+ $scriptTemplates = Join-Path $resourceScripts \"templates\"\n+\n+ New-Item -ItemType Directory -Path $referenceCommands, $referenceDocs, $referenceGuides, $scriptTemplates -Force | Out-Null\n+\n+ Copy-Item -Path (Join-Path $pluginDir \"HARNESS.md\") -Destination (Join-Path $referenceDir \"HARNESS.md\")\n+ Copy-Item -Path (Join-Path $pluginDir \"commands/*.md\") -Destination $referenceCommands\n+ Copy-Item -Path (Join-Path $pluginDir \"guides/*.md\") -Destination $referenceGuides\n+ Copy-Item -Path (Join-Path $pluginDir \"repl_skin.py\") -Destination (Join-Path $resourceScripts \"repl_skin.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"preview_bundle.py\") -Destination (Join-Path $resourceScripts \"preview_bundle.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"skill_generator.py\") -Destination (Join-Path $resourceScripts \"skill_generator.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"templates/*\") -Destination $scriptTemplates\n+ Copy-Item -Path $previewProtocol -Destination (Join-Path $referenceDocs \"PREVIEW_PROTOCOL.md\")\n+\n+ Move-Item -Path $stagingDir -Destination $destDir\n+} finally {\n+ if ($stagingDir -and (Test-Path $stagingDir)) {\n+ Remove-Item -Path $stagingDir -Recurse -Force\n+ }\n+}\n \n Write-Host \"Installed Codex skill to: $destDir\"\n+Write-Host \"Vendored CLI-Anything methodology resources into the installed skill.\"\n Write-Host \"Restart Codex to pick up the new skill.\"\n"},{"comment":"Similar to the Bash installer, `Copy-Item` will copy *into* an existing `$stagingDir` (creating an extra nesting level) rather than producing the expected staged layout. Because `$stagingDir` is deterministic per PID/session, it can exist from a previous interrupted run. Consider using a random/unique staging directory name (or creating it first and throwing if it exists), and ensure any pre-existing path is removed before the copy to prevent malformed installs.","path":"codex-skill/scripts/install.ps1","hunk":"@@ -13,14 +16,50 @@ $codexHome = if ($env:CODEX_HOME) {\n \n $destRoot = Join-Path $codexHome \"skills\"\n $destDir = Join-Path $destRoot \"cli-anything\"\n+$stagingDir = Join-Path $destRoot \".cli-anything.tmp.$PID\"\n+\n+if (-not (Test-Path (Join-Path $pluginDir \"HARNESS.md\"))) {\n+ throw \"Cannot find canonical CLI-Anything resources at: $pluginDir`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n+\n+if (-not (Test-Path $previewProtocol)) {\n+ throw \"Cannot find preview protocol at: $previewProtocol`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n \n New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\n \n if (Test-Path $destDir) {\n- Write-Error \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n+ throw \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n }\n \n-Copy-Item -Path $skillDir -Destination $destDir -Recurse\n+try {\n+ Copy-Item -Path $skillDir -Destination $stagingDir -Recurse","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/scripts/install.ps1 b/codex-skill/scripts/install.ps1\nindex ac58bd2134..a2e932748c 100644\n--- a/codex-skill/scripts/install.ps1\n+++ b/codex-skill/scripts/install.ps1\n@@ -2,6 +2,9 @@ $ErrorActionPreference = \"Stop\"\n \n $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path\n $skillDir = Split-Path -Parent $scriptDir\n+$repoRoot = Split-Path -Parent $skillDir\n+$pluginDir = Join-Path $repoRoot \"cli-anything-plugin\"\n+$previewProtocol = Join-Path $repoRoot \"docs/PREVIEW_PROTOCOL.md\"\n \n $codexHome = if ($env:CODEX_HOME) {\n $env:CODEX_HOME\n@@ -13,14 +16,52 @@ $codexHome = if ($env:CODEX_HOME) {\n \n $destRoot = Join-Path $codexHome \"skills\"\n $destDir = Join-Path $destRoot \"cli-anything\"\n+$stagingDir = $null\n+\n+if (-not (Test-Path (Join-Path $pluginDir \"HARNESS.md\"))) {\n+ throw \"Cannot find canonical CLI-Anything resources at: $pluginDir`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n+\n+if (-not (Test-Path $previewProtocol)) {\n+ throw \"Cannot find preview protocol at: $previewProtocol`nRun this installer from a full CLI-Anything repository checkout.\"\n+}\n \n New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\n \n if (Test-Path $destDir) {\n- Write-Error \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n+ throw \"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\"\n }\n \n-Copy-Item -Path $skillDir -Destination $destDir -Recurse\n+try {\n+ $stagingDir = Join-Path $destRoot (\".cli-anything.tmp.\" + [System.Guid]::NewGuid().ToString(\"N\"))\n+ New-Item -ItemType Directory -Path $stagingDir | Out-Null\n+ Get-ChildItem -LiteralPath $skillDir -Force | Copy-Item -Destination $stagingDir -Recurse -Force\n+\n+ $referenceDir = Join-Path $stagingDir \"references\"\n+ $referenceCommands = Join-Path $referenceDir \"commands\"\n+ $referenceDocs = Join-Path $referenceDir \"docs\"\n+ $referenceGuides = Join-Path $referenceDir \"guides\"\n+ $resourceScripts = Join-Path $stagingDir \"scripts\"\n+ $scriptTemplates = Join-Path $resourceScripts \"templates\"\n+\n+ New-Item -ItemType Directory -Path $referenceCommands, $referenceDocs, $referenceGuides, $scriptTemplates -Force | Out-Null\n+\n+ Copy-Item -Path (Join-Path $pluginDir \"HARNESS.md\") -Destination (Join-Path $referenceDir \"HARNESS.md\")\n+ Copy-Item -Path (Join-Path $pluginDir \"commands/*.md\") -Destination $referenceCommands\n+ Copy-Item -Path (Join-Path $pluginDir \"guides/*.md\") -Destination $referenceGuides\n+ Copy-Item -Path (Join-Path $pluginDir \"repl_skin.py\") -Destination (Join-Path $resourceScripts \"repl_skin.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"preview_bundle.py\") -Destination (Join-Path $resourceScripts \"preview_bundle.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"skill_generator.py\") -Destination (Join-Path $resourceScripts \"skill_generator.py\")\n+ Copy-Item -Path (Join-Path $pluginDir \"templates/*\") -Destination $scriptTemplates\n+ Copy-Item -Path $previewProtocol -Destination (Join-Path $referenceDocs \"PREVIEW_PROTOCOL.md\")\n+\n+ Move-Item -Path $stagingDir -Destination $destDir\n+} finally {\n+ if ($stagingDir -and (Test-Path $stagingDir)) {\n+ Remove-Item -Path $stagingDir -Recurse -Force\n+ }\n+}\n \n Write-Host \"Installed Codex skill to: $destDir\"\n+Write-Host \"Vendored CLI-Anything methodology resources into the installed skill.\"\n Write-Host \"Restart Codex to pick up the new skill.\"\n"},{"comment":"With `set -euo pipefail`, these glob-based `cp` commands fail with a generic shell error if a glob doesn’t match (e.g., temporarily empty `guides/` or a refactor that moves templates). That produces a poor failure mode and makes diagnosing installer failures harder. Consider adding explicit preflight checks that validate the expected directories/files exist (and that at least one `*.md` is present where required), and fail with a targeted error message that explains what’s missing.","path":"codex-skill/scripts/install.sh","hunk":"@@ -15,7 +31,30 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ rm -rf \"${STAGING_DIR}\"\n+}\n+trap cleanup EXIT\n+\n+cp -R \"${SKILL_DIR}\" \"${STAGING_DIR}\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/assets\" \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\nindex aa14514d8c..0646e3f460 100755\n--- a/codex-skill/scripts/install.sh\n+++ b/codex-skill/scripts/install.sh\n@@ -4,8 +4,24 @@ set -euo pipefail\n \n SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+PREVIEW_PROTOCOL=\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\"\n DEST_ROOT=\"${CODEX_HOME:-$HOME/.codex}/skills\"\n DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+STAGING_DIR=\"\"\n+\n+if [[ ! -f \"${PLUGIN_DIR}/HARNESS.md\" ]]; then\n+ echo \"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n+\n+if [[ ! -f \"${PREVIEW_PROTOCOL}\" ]]; then\n+ echo \"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n \n mkdir -p \"${DEST_ROOT}\"\n \n@@ -15,7 +31,32 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ if [[ -n \"${STAGING_DIR}\" && -d \"${STAGING_DIR}\" ]]; then\n+ rm -rf \"${STAGING_DIR}\"\n+ fi\n+}\n+trap cleanup EXIT\n+\n+STAGING_DIR=\"$(mktemp -d \"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\")\"\n+cp -R \"${SKILL_DIR}/.\" \"${STAGING_DIR}/\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts/templates\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/scripts/templates/\"\n+cp \"${PREVIEW_PROTOCOL}\" \"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+\n+mv \"${STAGING_DIR}\" \"${DEST_DIR}\"\n \n echo \"Installed Codex skill to: ${DEST_DIR}\"\n+echo \"Vendored CLI-Anything methodology resources into the installed skill.\"\n echo \"Restart Codex to pick up the new skill.\"\n"},{"comment":"With `set -euo pipefail`, these glob-based `cp` commands fail with a generic shell error if a glob doesn’t match (e.g., temporarily empty `guides/` or a refactor that moves templates). That produces a poor failure mode and makes diagnosing installer failures harder. Consider adding explicit preflight checks that validate the expected directories/files exist (and that at least one `*.md` is present where required), and fail with a targeted error message that explains what’s missing.","path":"codex-skill/scripts/install.sh","hunk":"@@ -15,7 +31,30 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ rm -rf \"${STAGING_DIR}\"\n+}\n+trap cleanup EXIT\n+\n+cp -R \"${SKILL_DIR}\" \"${STAGING_DIR}\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/assets\" \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/assets/\"","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\nindex aa14514d8c..0646e3f460 100755\n--- a/codex-skill/scripts/install.sh\n+++ b/codex-skill/scripts/install.sh\n@@ -4,8 +4,24 @@ set -euo pipefail\n \n SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+PREVIEW_PROTOCOL=\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\"\n DEST_ROOT=\"${CODEX_HOME:-$HOME/.codex}/skills\"\n DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+STAGING_DIR=\"\"\n+\n+if [[ ! -f \"${PLUGIN_DIR}/HARNESS.md\" ]]; then\n+ echo \"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n+\n+if [[ ! -f \"${PREVIEW_PROTOCOL}\" ]]; then\n+ echo \"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n \n mkdir -p \"${DEST_ROOT}\"\n \n@@ -15,7 +31,32 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ if [[ -n \"${STAGING_DIR}\" && -d \"${STAGING_DIR}\" ]]; then\n+ rm -rf \"${STAGING_DIR}\"\n+ fi\n+}\n+trap cleanup EXIT\n+\n+STAGING_DIR=\"$(mktemp -d \"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\")\"\n+cp -R \"${SKILL_DIR}/.\" \"${STAGING_DIR}/\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts/templates\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/scripts/templates/\"\n+cp \"${PREVIEW_PROTOCOL}\" \"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+\n+mv \"${STAGING_DIR}\" \"${DEST_DIR}\"\n \n echo \"Installed Codex skill to: ${DEST_DIR}\"\n+echo \"Vendored CLI-Anything methodology resources into the installed skill.\"\n echo \"Restart Codex to pick up the new skill.\"\n"},{"comment":"The markdown tables use `||` at the start of each row, which renders as an extra empty first column in most Markdown parsers (and can break table formatting in some renderers). Change these to standard table syntax with a single leading `|` per row (e.g., `| Path | Purpose |`) to ensure consistent rendering.","path":"codex-skill/SKILL.md","hunk":"@@ -1,13 +1,57 @@\n ---\n name: cli-anything\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\n ---\n \n # CLI-Anything for Codex\n \n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\n \n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\n+## Read the Full Methodology First\n+\n+Before implementation, use the full methodology source of truth:\n+\n+1. Read `references/HARNESS.md` relative to this skill directory.\n+2. Read the matching mode specification under `references/commands/`.\n+3. Read referenced files under `references/guides/` only when they apply to the target.\n+4. If the installed resources are unavailable and this skill is being used from a\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\n+ the resources around it.\n+5. If neither local source is available, clone or download\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\n+\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\n+skill so a normal Codex installation is self-contained.\n+\n+## Resource Map\n+\n+| Path | Purpose |\n+|------|---------|\n+| `references/HARNESS.md` | Complete methodology and quality rules |","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/SKILL.md b/codex-skill/SKILL.md\nindex 5d674e1603..c8f8ac1380 100644\n--- a/codex-skill/SKILL.md\n+++ b/codex-skill/SKILL.md\n@@ -1,13 +1,57 @@\n ---\n name: cli-anything\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\n ---\n \n # CLI-Anything for Codex\n \n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\n \n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\n+## Read the Full Methodology First\n+\n+Before implementation, use the full methodology source of truth:\n+\n+1. Read `references/HARNESS.md` relative to this skill directory.\n+2. Read the matching mode specification under `references/commands/`.\n+3. Read referenced files under `references/guides/` only when they apply to the target.\n+4. If the installed resources are unavailable and this skill is being used from a\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\n+ the resources around it.\n+5. If neither local source is available, clone or download\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\n+\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\n+skill so a normal Codex installation is self-contained.\n+\n+## Resource Map\n+\n+| Path | Purpose |\n+|------|---------|\n+| `references/HARNESS.md` | Complete methodology and quality rules |\n+| `references/commands/cli-anything.md` | Build-mode specification |\n+| `references/commands/refine.md` | Refine-mode specification |\n+| `references/commands/test.md` | Test-mode specification |\n+| `references/commands/validate.md` | Validation checklist |\n+| `references/commands/list.md` | Installed/generated harness discovery |\n+| `references/guides/` | On-demand implementation guidance |\n+| `scripts/repl_skin.py` | Copy into generated harnesses as `utils/repl_skin.py` |\n+| `scripts/preview_bundle.py` | Copy into preview-capable harnesses as `utils/preview_bundle.py` |\n+| `scripts/skill_generator.py` | Generate canonical and packaged CLI skills |\n+| `scripts/templates/SKILL.md.template` | Skill generation template used by `skill_generator.py` |\n+| `references/docs/PREVIEW_PROTOCOL.md` | Shared preview bundle protocol |\n+\n+When reading vendored documents, apply these path remappings instead of resolving\n+plugin paths against the current working directory:\n+\n+| Document reference | Installed skill path |\n+|--------------------|----------------------|\n+| `guides/...` | `references/guides/...` |\n+| `cli-anything-plugin/repl_skin.py` | `scripts/repl_skin.py` |\n+| `cli-anything-plugin/preview_bundle.py` | `scripts/preview_bundle.py` |\n+| `cli-anything-plugin/skill_generator.py` | `scripts/skill_generator.py` |\n+| `templates/SKILL.md.template` | `scripts/templates/SKILL.md.template` |\n+| `docs/PREVIEW_PROTOCOL.md` | `references/docs/PREVIEW_PROTOCOL.md` |\n \n ## Inputs\n \n@@ -22,9 +66,39 @@ Derive the software name from the local directory name after cloning if needed.\n \n ### Build\n \n-Use when the user wants a new harness.\n+Read `references/commands/cli-anything.md`. Build a complete harness through source\n+analysis, architecture design, implementation, test planning, test implementation,\n+test documentation, CLI-specific `SKILL.md` generation, and local installation.\n \n-Produce this structure:\n+### Refine\n+\n+Read `references/commands/refine.md`. Inventory current commands and tests, compare\n+them against the target software, then incrementally add high-impact capabilities\n+without removing existing commands unless the user requests a breaking change.\n+\n+### Test\n+\n+Read `references/commands/test.md`. Run the harness tests against the real backend,\n+verify installed-command subprocess coverage, and update `TEST.md` only with passing\n+results.\n+\n+### Validate\n+\n+Read `references/commands/validate.md`. Validate the harness against the complete\n+directory, implementation, test, documentation, packaging, and code-quality checklist.\n+\n+### List\n+\n+Read `references/commands/list.md`. Discover installed and generated CLI-Anything tools\n+and support human-readable or JSON output as requested.\n+\n+## Condensed Fallback Rules\n+\n+Use these only when the full methodology cannot be retrieved.\n+\n+### Harness Structure\n+\n+Produce:\n \n ```text\n <software>/\n@@ -42,63 +116,33 @@ Produce this structure:\n └── tests/\n ```\n \n-Implement a stateful Click CLI with:\n-\n-- one-shot subcommands\n-- REPL mode as the default when no subcommand is given\n-- `--json` machine-readable output\n-- session state with undo/redo where the target software supports it\n-\n-### Refine\n-\n-Use when the harness already exists.\n-\n-First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n-\n-- high-impact missing features\n-- easy wrappers around existing backend APIs or CLIs\n-- additions that compose well with existing commands\n-\n-Do not remove existing commands unless the user explicitly asks for a breaking change.\n-\n-### Test\n-\n-Plan tests before writing them. Keep both:\n-\n-- `test_core.py` for unit coverage\n-- `test_full_e2e.py` for workflow and backend validation\n-\n-When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n-\n-### Validate\n-\n-Check that the harness:\n-\n-- uses the `cli_anything.<software>` namespace package layout\n-- has an installable `setup.py` entry point\n-- supports JSON output\n-- has a REPL default path\n-- documents usage and tests\n-\n-## Backend Rules\n-\n-Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n-\n-## Packaging Rules\n-\n-- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n-- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n-- Expose `cli-anything-<software>` through `console_scripts`\n-\n-## Workflow\n-\n-1. Acquire the source tree locally.\n-2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n-3. Design command groups and state model.\n-4. Implement the harness.\n-5. Write `TEST.md`, then tests, then run them.\n-6. Update README usage docs.\n-7. Verify local installation with `pip install -e .`\n+### Required Behavior\n+\n+- Prefer the real software backend over reimplementation.\n+- Provide one-shot Click subcommands and default REPL mode.\n+- Support `--json` machine-readable output.\n+- Add session state with undo/redo where the target supports it.\n+- Auto-save one-shot session mutations and support `--dry-run`.\n+- Use locked session-file writes to avoid concurrent JSON corruption.\n+- Copy and use the unified `ReplSkin`.\n+- Add truthful preview commands for software with meaningful visual or inspection state.\n+- Generate both canonical and packaged CLI-specific `SKILL.md` files.\n+\n+### Testing\n+\n+- Write `TEST.md` before test code.\n+- Keep `test_core.py` for unit coverage.\n+- Keep `test_full_e2e.py` for real-file workflows and real backend validation.\n+- Verify rendered/exported output programmatically, not only process exit codes.\n+- Test the installed `cli-anything-<software>` command via `_resolve_cli()`.\n+- Run release validation with `CLI_ANYTHING_FORCE_INSTALLED=1`.\n+\n+### Packaging\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`.\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`.\n+- Expose `cli-anything-<software>` through `console_scripts`.\n+- Include the packaged CLI-specific `skills/SKILL.md`.\n \n ## Output Expectations\n \n"},{"comment":"The markdown tables use `||` at the start of each row, which renders as an extra empty first column in most Markdown parsers (and can break table formatting in some renderers). Change these to standard table syntax with a single leading `|` per row (e.g., `| Path | Purpose |`) to ensure consistent rendering.","path":"codex-skill/SKILL.md","hunk":"@@ -1,13 +1,57 @@\n ---\n name: cli-anything\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\n ---\n \n # CLI-Anything for Codex\n \n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\n \n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\n+## Read the Full Methodology First\n+\n+Before implementation, use the full methodology source of truth:\n+\n+1. Read `references/HARNESS.md` relative to this skill directory.\n+2. Read the matching mode specification under `references/commands/`.\n+3. Read referenced files under `references/guides/` only when they apply to the target.\n+4. If the installed resources are unavailable and this skill is being used from a\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\n+ the resources around it.\n+5. If neither local source is available, clone or download\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\n+\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\n+skill so a normal Codex installation is self-contained.\n+\n+## Resource Map\n+\n+| Path | Purpose |\n+|------|---------|\n+| `references/HARNESS.md` | Complete methodology and quality rules |\n+| `references/commands/cli-anything.md` | Build-mode specification |\n+| `references/commands/refine.md` | Refine-mode specification |\n+| `references/commands/test.md` | Test-mode specification |\n+| `references/commands/validate.md` | Validation checklist |\n+| `references/commands/list.md` | Installed/generated harness discovery |\n+| `references/guides/` | On-demand implementation guidance |\n+| `scripts/repl_skin.py` | Copy into generated harnesses as `utils/repl_skin.py` |\n+| `scripts/preview_bundle.py` | Copy into preview-capable harnesses as `utils/preview_bundle.py` |\n+| `scripts/skill_generator.py` | Generate canonical and packaged CLI skills |\n+| `assets/SKILL.md.template` | Skill generation template |\n+| `references/docs/PREVIEW_PROTOCOL.md` | Shared preview bundle protocol |\n+\n+When reading vendored documents, apply these path remappings instead of resolving\n+plugin paths against the current working directory:\n+\n+| Document reference | Installed skill path |\n+|--------------------|----------------------|\n+| `guides/...` | `references/guides/...` |","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/SKILL.md b/codex-skill/SKILL.md\nindex 5d674e1603..c8f8ac1380 100644\n--- a/codex-skill/SKILL.md\n+++ b/codex-skill/SKILL.md\n@@ -1,13 +1,57 @@\n ---\n name: cli-anything\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\n ---\n \n # CLI-Anything for Codex\n \n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\n \n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\n+## Read the Full Methodology First\n+\n+Before implementation, use the full methodology source of truth:\n+\n+1. Read `references/HARNESS.md` relative to this skill directory.\n+2. Read the matching mode specification under `references/commands/`.\n+3. Read referenced files under `references/guides/` only when they apply to the target.\n+4. If the installed resources are unavailable and this skill is being used from a\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\n+ the resources around it.\n+5. If neither local source is available, clone or download\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\n+\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\n+skill so a normal Codex installation is self-contained.\n+\n+## Resource Map\n+\n+| Path | Purpose |\n+|------|---------|\n+| `references/HARNESS.md` | Complete methodology and quality rules |\n+| `references/commands/cli-anything.md` | Build-mode specification |\n+| `references/commands/refine.md` | Refine-mode specification |\n+| `references/commands/test.md` | Test-mode specification |\n+| `references/commands/validate.md` | Validation checklist |\n+| `references/commands/list.md` | Installed/generated harness discovery |\n+| `references/guides/` | On-demand implementation guidance |\n+| `scripts/repl_skin.py` | Copy into generated harnesses as `utils/repl_skin.py` |\n+| `scripts/preview_bundle.py` | Copy into preview-capable harnesses as `utils/preview_bundle.py` |\n+| `scripts/skill_generator.py` | Generate canonical and packaged CLI skills |\n+| `scripts/templates/SKILL.md.template` | Skill generation template used by `skill_generator.py` |\n+| `references/docs/PREVIEW_PROTOCOL.md` | Shared preview bundle protocol |\n+\n+When reading vendored documents, apply these path remappings instead of resolving\n+plugin paths against the current working directory:\n+\n+| Document reference | Installed skill path |\n+|--------------------|----------------------|\n+| `guides/...` | `references/guides/...` |\n+| `cli-anything-plugin/repl_skin.py` | `scripts/repl_skin.py` |\n+| `cli-anything-plugin/preview_bundle.py` | `scripts/preview_bundle.py` |\n+| `cli-anything-plugin/skill_generator.py` | `scripts/skill_generator.py` |\n+| `templates/SKILL.md.template` | `scripts/templates/SKILL.md.template` |\n+| `docs/PREVIEW_PROTOCOL.md` | `references/docs/PREVIEW_PROTOCOL.md` |\n \n ## Inputs\n \n@@ -22,9 +66,39 @@ Derive the software name from the local directory name after cloning if needed.\n \n ### Build\n \n-Use when the user wants a new harness.\n+Read `references/commands/cli-anything.md`. Build a complete harness through source\n+analysis, architecture design, implementation, test planning, test implementation,\n+test documentation, CLI-specific `SKILL.md` generation, and local installation.\n \n-Produce this structure:\n+### Refine\n+\n+Read `references/commands/refine.md`. Inventory current commands and tests, compare\n+them against the target software, then incrementally add high-impact capabilities\n+without removing existing commands unless the user requests a breaking change.\n+\n+### Test\n+\n+Read `references/commands/test.md`. Run the harness tests against the real backend,\n+verify installed-command subprocess coverage, and update `TEST.md` only with passing\n+results.\n+\n+### Validate\n+\n+Read `references/commands/validate.md`. Validate the harness against the complete\n+directory, implementation, test, documentation, packaging, and code-quality checklist.\n+\n+### List\n+\n+Read `references/commands/list.md`. Discover installed and generated CLI-Anything tools\n+and support human-readable or JSON output as requested.\n+\n+## Condensed Fallback Rules\n+\n+Use these only when the full methodology cannot be retrieved.\n+\n+### Harness Structure\n+\n+Produce:\n \n ```text\n <software>/\n@@ -42,63 +116,33 @@ Produce this structure:\n └── tests/\n ```\n \n-Implement a stateful Click CLI with:\n-\n-- one-shot subcommands\n-- REPL mode as the default when no subcommand is given\n-- `--json` machine-readable output\n-- session state with undo/redo where the target software supports it\n-\n-### Refine\n-\n-Use when the harness already exists.\n-\n-First inventory current commands and tests, then do gap analysis against the target software. Prefer:\n-\n-- high-impact missing features\n-- easy wrappers around existing backend APIs or CLIs\n-- additions that compose well with existing commands\n-\n-Do not remove existing commands unless the user explicitly asks for a breaking change.\n-\n-### Test\n-\n-Plan tests before writing them. Keep both:\n-\n-- `test_core.py` for unit coverage\n-- `test_full_e2e.py` for workflow and backend validation\n-\n-When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\n-\n-### Validate\n-\n-Check that the harness:\n-\n-- uses the `cli_anything.<software>` namespace package layout\n-- has an installable `setup.py` entry point\n-- supports JSON output\n-- has a REPL default path\n-- documents usage and tests\n-\n-## Backend Rules\n-\n-Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\n-\n-## Packaging Rules\n-\n-- Use `find_namespace_packages(include=[\"cli_anything.*\"])`\n-- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\n-- Expose `cli-anything-<software>` through `console_scripts`\n-\n-## Workflow\n-\n-1. Acquire the source tree locally.\n-2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\n-3. Design command groups and state model.\n-4. Implement the harness.\n-5. Write `TEST.md`, then tests, then run them.\n-6. Update README usage docs.\n-7. Verify local installation with `pip install -e .`\n+### Required Behavior\n+\n+- Prefer the real software backend over reimplementation.\n+- Provide one-shot Click subcommands and default REPL mode.\n+- Support `--json` machine-readable output.\n+- Add session state with undo/redo where the target supports it.\n+- Auto-save one-shot session mutations and support `--dry-run`.\n+- Use locked session-file writes to avoid concurrent JSON corruption.\n+- Copy and use the unified `ReplSkin`.\n+- Add truthful preview commands for software with meaningful visual or inspection state.\n+- Generate both canonical and packaged CLI-specific `SKILL.md` files.\n+\n+### Testing\n+\n+- Write `TEST.md` before test code.\n+- Keep `test_core.py` for unit coverage.\n+- Keep `test_full_e2e.py` for real-file workflows and real backend validation.\n+- Verify rendered/exported output programmatically, not only process exit codes.\n+- Test the installed `cli-anything-<software>` command via `_resolve_cli()`.\n+- Run release validation with `CLI_ANYTHING_FORCE_INSTALLED=1`.\n+\n+### Packaging\n+\n+- Use `find_namespace_packages(include=[\"cli_anything.*\"])`.\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`.\n+- Expose `cli-anything-<software>` through `console_scripts`.\n+- Include the packaged CLI-specific `skills/SKILL.md`.\n \n ## Output Expectations\n \n"},{"comment":"**<sub><sub></sub></sub> Place the vendored skill template where the generator loads it**\n\nWhen the installed skill later uses the vendored `scripts/skill_generator.py` with its default settings, the generator looks for `Path(__file__).parent / \"templates\" / \"SKILL.md.template\"`, i.e. `scripts/templates/SKILL.md.template` after installation. This line copies the template only to `assets/`, so the default template is never found and generation silently falls back to the simpler non-canonical output whenever Jinja2 is available and no custom template path is passed. Copy the template to the path the generator expects, or adjust the vendored generator to look in `assets/`.\n\nUseful? React with 👍 / 👎.","path":"codex-skill/scripts/install.sh","hunk":"@@ -15,7 +31,30 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ rm -rf \"${STAGING_DIR}\"\n+}\n+trap cleanup EXIT\n+\n+cp -R \"${SKILL_DIR}\" \"${STAGING_DIR}\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/assets\" \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/assets/\"","resolving_sha":"96a4983e77439924765222dfd3103139627ae0c1","resolving_diff":"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\nindex aa14514d8c..0646e3f460 100755\n--- a/codex-skill/scripts/install.sh\n+++ b/codex-skill/scripts/install.sh\n@@ -4,8 +4,24 @@ set -euo pipefail\n \n SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+PREVIEW_PROTOCOL=\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\"\n DEST_ROOT=\"${CODEX_HOME:-$HOME/.codex}/skills\"\n DEST_DIR=\"${DEST_ROOT}/cli-anything\"\n+STAGING_DIR=\"\"\n+\n+if [[ ! -f \"${PLUGIN_DIR}/HARNESS.md\" ]]; then\n+ echo \"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n+\n+if [[ ! -f \"${PREVIEW_PROTOCOL}\" ]]; then\n+ echo \"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\" >&2\n+ echo \"Run this installer from a full CLI-Anything repository checkout.\" >&2\n+ exit 1\n+fi\n \n mkdir -p \"${DEST_ROOT}\"\n \n@@ -15,7 +31,32 @@ if [[ -e \"${DEST_DIR}\" ]]; then\n exit 1\n fi\n \n-cp -R \"${SKILL_DIR}\" \"${DEST_DIR}\"\n+cleanup() {\n+ if [[ -n \"${STAGING_DIR}\" && -d \"${STAGING_DIR}\" ]]; then\n+ rm -rf \"${STAGING_DIR}\"\n+ fi\n+}\n+trap cleanup EXIT\n+\n+STAGING_DIR=\"$(mktemp -d \"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\")\"\n+cp -R \"${SKILL_DIR}/.\" \"${STAGING_DIR}/\"\n+mkdir -p \\\n+ \"${STAGING_DIR}/references/commands\" \\\n+ \"${STAGING_DIR}/references/docs\" \\\n+ \"${STAGING_DIR}/references/guides\" \\\n+ \"${STAGING_DIR}/scripts/templates\"\n+\n+cp \"${PLUGIN_DIR}/HARNESS.md\" \"${STAGING_DIR}/references/HARNESS.md\"\n+cp \"${PLUGIN_DIR}/commands/\"*.md \"${STAGING_DIR}/references/commands/\"\n+cp \"${PLUGIN_DIR}/guides/\"*.md \"${STAGING_DIR}/references/guides/\"\n+cp \"${PLUGIN_DIR}/repl_skin.py\" \"${STAGING_DIR}/scripts/repl_skin.py\"\n+cp \"${PLUGIN_DIR}/preview_bundle.py\" \"${STAGING_DIR}/scripts/preview_bundle.py\"\n+cp \"${PLUGIN_DIR}/skill_generator.py\" \"${STAGING_DIR}/scripts/skill_generator.py\"\n+cp \"${PLUGIN_DIR}/templates/\"* \"${STAGING_DIR}/scripts/templates/\"\n+cp \"${PREVIEW_PROTOCOL}\" \"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+\n+mv \"${STAGING_DIR}\" \"${DEST_DIR}\"\n \n echo \"Installed Codex skill to: ${DEST_DIR}\"\n+echo \"Vendored CLI-Anything methodology resources into the installed skill.\"\n echo \"Restart Codex to pick up the new skill.\"\n"}],"string":"[\n {\n \"comment\": \"`cp -R \\\"${SKILL_DIR}\\\" \\\"${STAGING_DIR}\\\"` behaves differently if `${STAGING_DIR}` already exists (it will copy the skill into a nested subdirectory), which can produce a broken install layout. Since `${STAGING_DIR}` is a predictable name, it can be left behind from a prior crash or collide with a concurrent run. Use a guaranteed-unique temp dir (e.g., `mktemp -d` under `${DEST_ROOT}`) and/or explicitly remove/abort when `${STAGING_DIR}` exists before copying.\",\n \"path\": \"codex-skill/scripts/install.sh\",\n \"hunk\": \"@@ -4,8 +4,24 @@ set -euo pipefail\\n \\n SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n SKILL_DIR=\\\"$(cd \\\"${SCRIPT_DIR}/..\\\" && pwd)\\\"\\n+REPO_ROOT=\\\"$(cd \\\"${SKILL_DIR}/..\\\" && pwd)\\\"\\n+PLUGIN_DIR=\\\"${REPO_ROOT}/cli-anything-plugin\\\"\\n+PREVIEW_PROTOCOL=\\\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\\\"\\n DEST_ROOT=\\\"${CODEX_HOME:-$HOME/.codex}/skills\\\"\\n DEST_DIR=\\\"${DEST_ROOT}/cli-anything\\\"\\n+STAGING_DIR=\\\"${DEST_ROOT}/.cli-anything.tmp.$$\\\"\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\\nindex aa14514d8c..0646e3f460 100755\\n--- a/codex-skill/scripts/install.sh\\n+++ b/codex-skill/scripts/install.sh\\n@@ -4,8 +4,24 @@ set -euo pipefail\\n \\n SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n SKILL_DIR=\\\"$(cd \\\"${SCRIPT_DIR}/..\\\" && pwd)\\\"\\n+REPO_ROOT=\\\"$(cd \\\"${SKILL_DIR}/..\\\" && pwd)\\\"\\n+PLUGIN_DIR=\\\"${REPO_ROOT}/cli-anything-plugin\\\"\\n+PREVIEW_PROTOCOL=\\\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\\\"\\n DEST_ROOT=\\\"${CODEX_HOME:-$HOME/.codex}/skills\\\"\\n DEST_DIR=\\\"${DEST_ROOT}/cli-anything\\\"\\n+STAGING_DIR=\\\"\\\"\\n+\\n+if [[ ! -f \\\"${PLUGIN_DIR}/HARNESS.md\\\" ]]; then\\n+ echo \\\"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n+\\n+if [[ ! -f \\\"${PREVIEW_PROTOCOL}\\\" ]]; then\\n+ echo \\\"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n \\n mkdir -p \\\"${DEST_ROOT}\\\"\\n \\n@@ -15,7 +31,32 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ if [[ -n \\\"${STAGING_DIR}\\\" && -d \\\"${STAGING_DIR}\\\" ]]; then\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+ fi\\n+}\\n+trap cleanup EXIT\\n+\\n+STAGING_DIR=\\\"$(mktemp -d \\\"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\\\")\\\"\\n+cp -R \\\"${SKILL_DIR}/.\\\" \\\"${STAGING_DIR}/\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts/templates\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\\n+cp \\\"${PLUGIN_DIR}/repl_skin.py\\\" \\\"${STAGING_DIR}/scripts/repl_skin.py\\\"\\n+cp \\\"${PLUGIN_DIR}/preview_bundle.py\\\" \\\"${STAGING_DIR}/scripts/preview_bundle.py\\\"\\n+cp \\\"${PLUGIN_DIR}/skill_generator.py\\\" \\\"${STAGING_DIR}/scripts/skill_generator.py\\\"\\n+cp \\\"${PLUGIN_DIR}/templates/\\\"* \\\"${STAGING_DIR}/scripts/templates/\\\"\\n+cp \\\"${PREVIEW_PROTOCOL}\\\" \\\"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\\\"\\n+\\n+mv \\\"${STAGING_DIR}\\\" \\\"${DEST_DIR}\\\"\\n \\n echo \\\"Installed Codex skill to: ${DEST_DIR}\\\"\\n+echo \\\"Vendored CLI-Anything methodology resources into the installed skill.\\\"\\n echo \\\"Restart Codex to pick up the new skill.\\\"\\n\"\n },\n {\n \"comment\": \"`cp -R \\\"${SKILL_DIR}\\\" \\\"${STAGING_DIR}\\\"` behaves differently if `${STAGING_DIR}` already exists (it will copy the skill into a nested subdirectory), which can produce a broken install layout. Since `${STAGING_DIR}` is a predictable name, it can be left behind from a prior crash or collide with a concurrent run. Use a guaranteed-unique temp dir (e.g., `mktemp -d` under `${DEST_ROOT}`) and/or explicitly remove/abort when `${STAGING_DIR}` exists before copying.\",\n \"path\": \"codex-skill/scripts/install.sh\",\n \"hunk\": \"@@ -15,7 +31,30 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+}\\n+trap cleanup EXIT\\n+\\n+cp -R \\\"${SKILL_DIR}\\\" \\\"${STAGING_DIR}\\\"\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\\nindex aa14514d8c..0646e3f460 100755\\n--- a/codex-skill/scripts/install.sh\\n+++ b/codex-skill/scripts/install.sh\\n@@ -4,8 +4,24 @@ set -euo pipefail\\n \\n SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n SKILL_DIR=\\\"$(cd \\\"${SCRIPT_DIR}/..\\\" && pwd)\\\"\\n+REPO_ROOT=\\\"$(cd \\\"${SKILL_DIR}/..\\\" && pwd)\\\"\\n+PLUGIN_DIR=\\\"${REPO_ROOT}/cli-anything-plugin\\\"\\n+PREVIEW_PROTOCOL=\\\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\\\"\\n DEST_ROOT=\\\"${CODEX_HOME:-$HOME/.codex}/skills\\\"\\n DEST_DIR=\\\"${DEST_ROOT}/cli-anything\\\"\\n+STAGING_DIR=\\\"\\\"\\n+\\n+if [[ ! -f \\\"${PLUGIN_DIR}/HARNESS.md\\\" ]]; then\\n+ echo \\\"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n+\\n+if [[ ! -f \\\"${PREVIEW_PROTOCOL}\\\" ]]; then\\n+ echo \\\"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n \\n mkdir -p \\\"${DEST_ROOT}\\\"\\n \\n@@ -15,7 +31,32 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ if [[ -n \\\"${STAGING_DIR}\\\" && -d \\\"${STAGING_DIR}\\\" ]]; then\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+ fi\\n+}\\n+trap cleanup EXIT\\n+\\n+STAGING_DIR=\\\"$(mktemp -d \\\"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\\\")\\\"\\n+cp -R \\\"${SKILL_DIR}/.\\\" \\\"${STAGING_DIR}/\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts/templates\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\\n+cp \\\"${PLUGIN_DIR}/repl_skin.py\\\" \\\"${STAGING_DIR}/scripts/repl_skin.py\\\"\\n+cp \\\"${PLUGIN_DIR}/preview_bundle.py\\\" \\\"${STAGING_DIR}/scripts/preview_bundle.py\\\"\\n+cp \\\"${PLUGIN_DIR}/skill_generator.py\\\" \\\"${STAGING_DIR}/scripts/skill_generator.py\\\"\\n+cp \\\"${PLUGIN_DIR}/templates/\\\"* \\\"${STAGING_DIR}/scripts/templates/\\\"\\n+cp \\\"${PREVIEW_PROTOCOL}\\\" \\\"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\\\"\\n+\\n+mv \\\"${STAGING_DIR}\\\" \\\"${DEST_DIR}\\\"\\n \\n echo \\\"Installed Codex skill to: ${DEST_DIR}\\\"\\n+echo \\\"Vendored CLI-Anything methodology resources into the installed skill.\\\"\\n echo \\\"Restart Codex to pick up the new skill.\\\"\\n\"\n },\n {\n \"comment\": \"Similar to the Bash installer, `Copy-Item` will copy *into* an existing `$stagingDir` (creating an extra nesting level) rather than producing the expected staged layout. Because `$stagingDir` is deterministic per PID/session, it can exist from a previous interrupted run. Consider using a random/unique staging directory name (or creating it first and throwing if it exists), and ensure any pre-existing path is removed before the copy to prevent malformed installs.\",\n \"path\": \"codex-skill/scripts/install.ps1\",\n \"hunk\": \"@@ -13,14 +16,50 @@ $codexHome = if ($env:CODEX_HOME) {\\n \\n $destRoot = Join-Path $codexHome \\\"skills\\\"\\n $destDir = Join-Path $destRoot \\\"cli-anything\\\"\\n+$stagingDir = Join-Path $destRoot \\\".cli-anything.tmp.$PID\\\"\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/scripts/install.ps1 b/codex-skill/scripts/install.ps1\\nindex ac58bd2134..a2e932748c 100644\\n--- a/codex-skill/scripts/install.ps1\\n+++ b/codex-skill/scripts/install.ps1\\n@@ -2,6 +2,9 @@ $ErrorActionPreference = \\\"Stop\\\"\\n \\n $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path\\n $skillDir = Split-Path -Parent $scriptDir\\n+$repoRoot = Split-Path -Parent $skillDir\\n+$pluginDir = Join-Path $repoRoot \\\"cli-anything-plugin\\\"\\n+$previewProtocol = Join-Path $repoRoot \\\"docs/PREVIEW_PROTOCOL.md\\\"\\n \\n $codexHome = if ($env:CODEX_HOME) {\\n $env:CODEX_HOME\\n@@ -13,14 +16,52 @@ $codexHome = if ($env:CODEX_HOME) {\\n \\n $destRoot = Join-Path $codexHome \\\"skills\\\"\\n $destDir = Join-Path $destRoot \\\"cli-anything\\\"\\n+$stagingDir = $null\\n+\\n+if (-not (Test-Path (Join-Path $pluginDir \\\"HARNESS.md\\\"))) {\\n+ throw \\\"Cannot find canonical CLI-Anything resources at: $pluginDir`nRun this installer from a full CLI-Anything repository checkout.\\\"\\n+}\\n+\\n+if (-not (Test-Path $previewProtocol)) {\\n+ throw \\\"Cannot find preview protocol at: $previewProtocol`nRun this installer from a full CLI-Anything repository checkout.\\\"\\n+}\\n \\n New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\\n \\n if (Test-Path $destDir) {\\n- Write-Error \\\"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\\\"\\n+ throw \\\"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\\\"\\n }\\n \\n-Copy-Item -Path $skillDir -Destination $destDir -Recurse\\n+try {\\n+ $stagingDir = Join-Path $destRoot (\\\".cli-anything.tmp.\\\" + [System.Guid]::NewGuid().ToString(\\\"N\\\"))\\n+ New-Item -ItemType Directory -Path $stagingDir | Out-Null\\n+ Get-ChildItem -LiteralPath $skillDir -Force | Copy-Item -Destination $stagingDir -Recurse -Force\\n+\\n+ $referenceDir = Join-Path $stagingDir \\\"references\\\"\\n+ $referenceCommands = Join-Path $referenceDir \\\"commands\\\"\\n+ $referenceDocs = Join-Path $referenceDir \\\"docs\\\"\\n+ $referenceGuides = Join-Path $referenceDir \\\"guides\\\"\\n+ $resourceScripts = Join-Path $stagingDir \\\"scripts\\\"\\n+ $scriptTemplates = Join-Path $resourceScripts \\\"templates\\\"\\n+\\n+ New-Item -ItemType Directory -Path $referenceCommands, $referenceDocs, $referenceGuides, $scriptTemplates -Force | Out-Null\\n+\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"HARNESS.md\\\") -Destination (Join-Path $referenceDir \\\"HARNESS.md\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"commands/*.md\\\") -Destination $referenceCommands\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"guides/*.md\\\") -Destination $referenceGuides\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"repl_skin.py\\\") -Destination (Join-Path $resourceScripts \\\"repl_skin.py\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"preview_bundle.py\\\") -Destination (Join-Path $resourceScripts \\\"preview_bundle.py\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"skill_generator.py\\\") -Destination (Join-Path $resourceScripts \\\"skill_generator.py\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"templates/*\\\") -Destination $scriptTemplates\\n+ Copy-Item -Path $previewProtocol -Destination (Join-Path $referenceDocs \\\"PREVIEW_PROTOCOL.md\\\")\\n+\\n+ Move-Item -Path $stagingDir -Destination $destDir\\n+} finally {\\n+ if ($stagingDir -and (Test-Path $stagingDir)) {\\n+ Remove-Item -Path $stagingDir -Recurse -Force\\n+ }\\n+}\\n \\n Write-Host \\\"Installed Codex skill to: $destDir\\\"\\n+Write-Host \\\"Vendored CLI-Anything methodology resources into the installed skill.\\\"\\n Write-Host \\\"Restart Codex to pick up the new skill.\\\"\\n\"\n },\n {\n \"comment\": \"Similar to the Bash installer, `Copy-Item` will copy *into* an existing `$stagingDir` (creating an extra nesting level) rather than producing the expected staged layout. Because `$stagingDir` is deterministic per PID/session, it can exist from a previous interrupted run. Consider using a random/unique staging directory name (or creating it first and throwing if it exists), and ensure any pre-existing path is removed before the copy to prevent malformed installs.\",\n \"path\": \"codex-skill/scripts/install.ps1\",\n \"hunk\": \"@@ -13,14 +16,50 @@ $codexHome = if ($env:CODEX_HOME) {\\n \\n $destRoot = Join-Path $codexHome \\\"skills\\\"\\n $destDir = Join-Path $destRoot \\\"cli-anything\\\"\\n+$stagingDir = Join-Path $destRoot \\\".cli-anything.tmp.$PID\\\"\\n+\\n+if (-not (Test-Path (Join-Path $pluginDir \\\"HARNESS.md\\\"))) {\\n+ throw \\\"Cannot find canonical CLI-Anything resources at: $pluginDir`nRun this installer from a full CLI-Anything repository checkout.\\\"\\n+}\\n+\\n+if (-not (Test-Path $previewProtocol)) {\\n+ throw \\\"Cannot find preview protocol at: $previewProtocol`nRun this installer from a full CLI-Anything repository checkout.\\\"\\n+}\\n \\n New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\\n \\n if (Test-Path $destDir) {\\n- Write-Error \\\"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\\\"\\n+ throw \\\"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\\\"\\n }\\n \\n-Copy-Item -Path $skillDir -Destination $destDir -Recurse\\n+try {\\n+ Copy-Item -Path $skillDir -Destination $stagingDir -Recurse\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/scripts/install.ps1 b/codex-skill/scripts/install.ps1\\nindex ac58bd2134..a2e932748c 100644\\n--- a/codex-skill/scripts/install.ps1\\n+++ b/codex-skill/scripts/install.ps1\\n@@ -2,6 +2,9 @@ $ErrorActionPreference = \\\"Stop\\\"\\n \\n $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path\\n $skillDir = Split-Path -Parent $scriptDir\\n+$repoRoot = Split-Path -Parent $skillDir\\n+$pluginDir = Join-Path $repoRoot \\\"cli-anything-plugin\\\"\\n+$previewProtocol = Join-Path $repoRoot \\\"docs/PREVIEW_PROTOCOL.md\\\"\\n \\n $codexHome = if ($env:CODEX_HOME) {\\n $env:CODEX_HOME\\n@@ -13,14 +16,52 @@ $codexHome = if ($env:CODEX_HOME) {\\n \\n $destRoot = Join-Path $codexHome \\\"skills\\\"\\n $destDir = Join-Path $destRoot \\\"cli-anything\\\"\\n+$stagingDir = $null\\n+\\n+if (-not (Test-Path (Join-Path $pluginDir \\\"HARNESS.md\\\"))) {\\n+ throw \\\"Cannot find canonical CLI-Anything resources at: $pluginDir`nRun this installer from a full CLI-Anything repository checkout.\\\"\\n+}\\n+\\n+if (-not (Test-Path $previewProtocol)) {\\n+ throw \\\"Cannot find preview protocol at: $previewProtocol`nRun this installer from a full CLI-Anything repository checkout.\\\"\\n+}\\n \\n New-Item -ItemType Directory -Path $destRoot -Force | Out-Null\\n \\n if (Test-Path $destDir) {\\n- Write-Error \\\"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\\\"\\n+ throw \\\"Refusing to overwrite existing skill: $destDir`nRemove it manually if you want to reinstall.\\\"\\n }\\n \\n-Copy-Item -Path $skillDir -Destination $destDir -Recurse\\n+try {\\n+ $stagingDir = Join-Path $destRoot (\\\".cli-anything.tmp.\\\" + [System.Guid]::NewGuid().ToString(\\\"N\\\"))\\n+ New-Item -ItemType Directory -Path $stagingDir | Out-Null\\n+ Get-ChildItem -LiteralPath $skillDir -Force | Copy-Item -Destination $stagingDir -Recurse -Force\\n+\\n+ $referenceDir = Join-Path $stagingDir \\\"references\\\"\\n+ $referenceCommands = Join-Path $referenceDir \\\"commands\\\"\\n+ $referenceDocs = Join-Path $referenceDir \\\"docs\\\"\\n+ $referenceGuides = Join-Path $referenceDir \\\"guides\\\"\\n+ $resourceScripts = Join-Path $stagingDir \\\"scripts\\\"\\n+ $scriptTemplates = Join-Path $resourceScripts \\\"templates\\\"\\n+\\n+ New-Item -ItemType Directory -Path $referenceCommands, $referenceDocs, $referenceGuides, $scriptTemplates -Force | Out-Null\\n+\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"HARNESS.md\\\") -Destination (Join-Path $referenceDir \\\"HARNESS.md\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"commands/*.md\\\") -Destination $referenceCommands\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"guides/*.md\\\") -Destination $referenceGuides\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"repl_skin.py\\\") -Destination (Join-Path $resourceScripts \\\"repl_skin.py\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"preview_bundle.py\\\") -Destination (Join-Path $resourceScripts \\\"preview_bundle.py\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"skill_generator.py\\\") -Destination (Join-Path $resourceScripts \\\"skill_generator.py\\\")\\n+ Copy-Item -Path (Join-Path $pluginDir \\\"templates/*\\\") -Destination $scriptTemplates\\n+ Copy-Item -Path $previewProtocol -Destination (Join-Path $referenceDocs \\\"PREVIEW_PROTOCOL.md\\\")\\n+\\n+ Move-Item -Path $stagingDir -Destination $destDir\\n+} finally {\\n+ if ($stagingDir -and (Test-Path $stagingDir)) {\\n+ Remove-Item -Path $stagingDir -Recurse -Force\\n+ }\\n+}\\n \\n Write-Host \\\"Installed Codex skill to: $destDir\\\"\\n+Write-Host \\\"Vendored CLI-Anything methodology resources into the installed skill.\\\"\\n Write-Host \\\"Restart Codex to pick up the new skill.\\\"\\n\"\n },\n {\n \"comment\": \"With `set -euo pipefail`, these glob-based `cp` commands fail with a generic shell error if a glob doesn’t match (e.g., temporarily empty `guides/` or a refactor that moves templates). That produces a poor failure mode and makes diagnosing installer failures harder. Consider adding explicit preflight checks that validate the expected directories/files exist (and that at least one `*.md` is present where required), and fail with a targeted error message that explains what’s missing.\",\n \"path\": \"codex-skill/scripts/install.sh\",\n \"hunk\": \"@@ -15,7 +31,30 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+}\\n+trap cleanup EXIT\\n+\\n+cp -R \\\"${SKILL_DIR}\\\" \\\"${STAGING_DIR}\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/assets\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\\nindex aa14514d8c..0646e3f460 100755\\n--- a/codex-skill/scripts/install.sh\\n+++ b/codex-skill/scripts/install.sh\\n@@ -4,8 +4,24 @@ set -euo pipefail\\n \\n SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n SKILL_DIR=\\\"$(cd \\\"${SCRIPT_DIR}/..\\\" && pwd)\\\"\\n+REPO_ROOT=\\\"$(cd \\\"${SKILL_DIR}/..\\\" && pwd)\\\"\\n+PLUGIN_DIR=\\\"${REPO_ROOT}/cli-anything-plugin\\\"\\n+PREVIEW_PROTOCOL=\\\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\\\"\\n DEST_ROOT=\\\"${CODEX_HOME:-$HOME/.codex}/skills\\\"\\n DEST_DIR=\\\"${DEST_ROOT}/cli-anything\\\"\\n+STAGING_DIR=\\\"\\\"\\n+\\n+if [[ ! -f \\\"${PLUGIN_DIR}/HARNESS.md\\\" ]]; then\\n+ echo \\\"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n+\\n+if [[ ! -f \\\"${PREVIEW_PROTOCOL}\\\" ]]; then\\n+ echo \\\"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n \\n mkdir -p \\\"${DEST_ROOT}\\\"\\n \\n@@ -15,7 +31,32 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ if [[ -n \\\"${STAGING_DIR}\\\" && -d \\\"${STAGING_DIR}\\\" ]]; then\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+ fi\\n+}\\n+trap cleanup EXIT\\n+\\n+STAGING_DIR=\\\"$(mktemp -d \\\"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\\\")\\\"\\n+cp -R \\\"${SKILL_DIR}/.\\\" \\\"${STAGING_DIR}/\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts/templates\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\\n+cp \\\"${PLUGIN_DIR}/repl_skin.py\\\" \\\"${STAGING_DIR}/scripts/repl_skin.py\\\"\\n+cp \\\"${PLUGIN_DIR}/preview_bundle.py\\\" \\\"${STAGING_DIR}/scripts/preview_bundle.py\\\"\\n+cp \\\"${PLUGIN_DIR}/skill_generator.py\\\" \\\"${STAGING_DIR}/scripts/skill_generator.py\\\"\\n+cp \\\"${PLUGIN_DIR}/templates/\\\"* \\\"${STAGING_DIR}/scripts/templates/\\\"\\n+cp \\\"${PREVIEW_PROTOCOL}\\\" \\\"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\\\"\\n+\\n+mv \\\"${STAGING_DIR}\\\" \\\"${DEST_DIR}\\\"\\n \\n echo \\\"Installed Codex skill to: ${DEST_DIR}\\\"\\n+echo \\\"Vendored CLI-Anything methodology resources into the installed skill.\\\"\\n echo \\\"Restart Codex to pick up the new skill.\\\"\\n\"\n },\n {\n \"comment\": \"With `set -euo pipefail`, these glob-based `cp` commands fail with a generic shell error if a glob doesn’t match (e.g., temporarily empty `guides/` or a refactor that moves templates). That produces a poor failure mode and makes diagnosing installer failures harder. Consider adding explicit preflight checks that validate the expected directories/files exist (and that at least one `*.md` is present where required), and fail with a targeted error message that explains what’s missing.\",\n \"path\": \"codex-skill/scripts/install.sh\",\n \"hunk\": \"@@ -15,7 +31,30 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+}\\n+trap cleanup EXIT\\n+\\n+cp -R \\\"${SKILL_DIR}\\\" \\\"${STAGING_DIR}\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/assets\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\\n+cp \\\"${PLUGIN_DIR}/repl_skin.py\\\" \\\"${STAGING_DIR}/scripts/repl_skin.py\\\"\\n+cp \\\"${PLUGIN_DIR}/preview_bundle.py\\\" \\\"${STAGING_DIR}/scripts/preview_bundle.py\\\"\\n+cp \\\"${PLUGIN_DIR}/skill_generator.py\\\" \\\"${STAGING_DIR}/scripts/skill_generator.py\\\"\\n+cp \\\"${PLUGIN_DIR}/templates/\\\"* \\\"${STAGING_DIR}/assets/\\\"\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\\nindex aa14514d8c..0646e3f460 100755\\n--- a/codex-skill/scripts/install.sh\\n+++ b/codex-skill/scripts/install.sh\\n@@ -4,8 +4,24 @@ set -euo pipefail\\n \\n SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n SKILL_DIR=\\\"$(cd \\\"${SCRIPT_DIR}/..\\\" && pwd)\\\"\\n+REPO_ROOT=\\\"$(cd \\\"${SKILL_DIR}/..\\\" && pwd)\\\"\\n+PLUGIN_DIR=\\\"${REPO_ROOT}/cli-anything-plugin\\\"\\n+PREVIEW_PROTOCOL=\\\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\\\"\\n DEST_ROOT=\\\"${CODEX_HOME:-$HOME/.codex}/skills\\\"\\n DEST_DIR=\\\"${DEST_ROOT}/cli-anything\\\"\\n+STAGING_DIR=\\\"\\\"\\n+\\n+if [[ ! -f \\\"${PLUGIN_DIR}/HARNESS.md\\\" ]]; then\\n+ echo \\\"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n+\\n+if [[ ! -f \\\"${PREVIEW_PROTOCOL}\\\" ]]; then\\n+ echo \\\"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n \\n mkdir -p \\\"${DEST_ROOT}\\\"\\n \\n@@ -15,7 +31,32 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ if [[ -n \\\"${STAGING_DIR}\\\" && -d \\\"${STAGING_DIR}\\\" ]]; then\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+ fi\\n+}\\n+trap cleanup EXIT\\n+\\n+STAGING_DIR=\\\"$(mktemp -d \\\"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\\\")\\\"\\n+cp -R \\\"${SKILL_DIR}/.\\\" \\\"${STAGING_DIR}/\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts/templates\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\\n+cp \\\"${PLUGIN_DIR}/repl_skin.py\\\" \\\"${STAGING_DIR}/scripts/repl_skin.py\\\"\\n+cp \\\"${PLUGIN_DIR}/preview_bundle.py\\\" \\\"${STAGING_DIR}/scripts/preview_bundle.py\\\"\\n+cp \\\"${PLUGIN_DIR}/skill_generator.py\\\" \\\"${STAGING_DIR}/scripts/skill_generator.py\\\"\\n+cp \\\"${PLUGIN_DIR}/templates/\\\"* \\\"${STAGING_DIR}/scripts/templates/\\\"\\n+cp \\\"${PREVIEW_PROTOCOL}\\\" \\\"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\\\"\\n+\\n+mv \\\"${STAGING_DIR}\\\" \\\"${DEST_DIR}\\\"\\n \\n echo \\\"Installed Codex skill to: ${DEST_DIR}\\\"\\n+echo \\\"Vendored CLI-Anything methodology resources into the installed skill.\\\"\\n echo \\\"Restart Codex to pick up the new skill.\\\"\\n\"\n },\n {\n \"comment\": \"The markdown tables use `||` at the start of each row, which renders as an extra empty first column in most Markdown parsers (and can break table formatting in some renderers). Change these to standard table syntax with a single leading `|` per row (e.g., `| Path | Purpose |`) to ensure consistent rendering.\",\n \"path\": \"codex-skill/SKILL.md\",\n \"hunk\": \"@@ -1,13 +1,57 @@\\n ---\\n name: cli-anything\\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\\n ---\\n \\n # CLI-Anything for Codex\\n \\n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\\n \\n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\\n+## Read the Full Methodology First\\n+\\n+Before implementation, use the full methodology source of truth:\\n+\\n+1. Read `references/HARNESS.md` relative to this skill directory.\\n+2. Read the matching mode specification under `references/commands/`.\\n+3. Read referenced files under `references/guides/` only when they apply to the target.\\n+4. If the installed resources are unavailable and this skill is being used from a\\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\\n+ the resources around it.\\n+5. If neither local source is available, clone or download\\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\\n+\\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\\n+skill so a normal Codex installation is self-contained.\\n+\\n+## Resource Map\\n+\\n+| Path | Purpose |\\n+|------|---------|\\n+| `references/HARNESS.md` | Complete methodology and quality rules |\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/SKILL.md b/codex-skill/SKILL.md\\nindex 5d674e1603..c8f8ac1380 100644\\n--- a/codex-skill/SKILL.md\\n+++ b/codex-skill/SKILL.md\\n@@ -1,13 +1,57 @@\\n ---\\n name: cli-anything\\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\\n ---\\n \\n # CLI-Anything for Codex\\n \\n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\\n \\n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\\n+## Read the Full Methodology First\\n+\\n+Before implementation, use the full methodology source of truth:\\n+\\n+1. Read `references/HARNESS.md` relative to this skill directory.\\n+2. Read the matching mode specification under `references/commands/`.\\n+3. Read referenced files under `references/guides/` only when they apply to the target.\\n+4. If the installed resources are unavailable and this skill is being used from a\\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\\n+ the resources around it.\\n+5. If neither local source is available, clone or download\\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\\n+\\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\\n+skill so a normal Codex installation is self-contained.\\n+\\n+## Resource Map\\n+\\n+| Path | Purpose |\\n+|------|---------|\\n+| `references/HARNESS.md` | Complete methodology and quality rules |\\n+| `references/commands/cli-anything.md` | Build-mode specification |\\n+| `references/commands/refine.md` | Refine-mode specification |\\n+| `references/commands/test.md` | Test-mode specification |\\n+| `references/commands/validate.md` | Validation checklist |\\n+| `references/commands/list.md` | Installed/generated harness discovery |\\n+| `references/guides/` | On-demand implementation guidance |\\n+| `scripts/repl_skin.py` | Copy into generated harnesses as `utils/repl_skin.py` |\\n+| `scripts/preview_bundle.py` | Copy into preview-capable harnesses as `utils/preview_bundle.py` |\\n+| `scripts/skill_generator.py` | Generate canonical and packaged CLI skills |\\n+| `scripts/templates/SKILL.md.template` | Skill generation template used by `skill_generator.py` |\\n+| `references/docs/PREVIEW_PROTOCOL.md` | Shared preview bundle protocol |\\n+\\n+When reading vendored documents, apply these path remappings instead of resolving\\n+plugin paths against the current working directory:\\n+\\n+| Document reference | Installed skill path |\\n+|--------------------|----------------------|\\n+| `guides/...` | `references/guides/...` |\\n+| `cli-anything-plugin/repl_skin.py` | `scripts/repl_skin.py` |\\n+| `cli-anything-plugin/preview_bundle.py` | `scripts/preview_bundle.py` |\\n+| `cli-anything-plugin/skill_generator.py` | `scripts/skill_generator.py` |\\n+| `templates/SKILL.md.template` | `scripts/templates/SKILL.md.template` |\\n+| `docs/PREVIEW_PROTOCOL.md` | `references/docs/PREVIEW_PROTOCOL.md` |\\n \\n ## Inputs\\n \\n@@ -22,9 +66,39 @@ Derive the software name from the local directory name after cloning if needed.\\n \\n ### Build\\n \\n-Use when the user wants a new harness.\\n+Read `references/commands/cli-anything.md`. Build a complete harness through source\\n+analysis, architecture design, implementation, test planning, test implementation,\\n+test documentation, CLI-specific `SKILL.md` generation, and local installation.\\n \\n-Produce this structure:\\n+### Refine\\n+\\n+Read `references/commands/refine.md`. Inventory current commands and tests, compare\\n+them against the target software, then incrementally add high-impact capabilities\\n+without removing existing commands unless the user requests a breaking change.\\n+\\n+### Test\\n+\\n+Read `references/commands/test.md`. Run the harness tests against the real backend,\\n+verify installed-command subprocess coverage, and update `TEST.md` only with passing\\n+results.\\n+\\n+### Validate\\n+\\n+Read `references/commands/validate.md`. Validate the harness against the complete\\n+directory, implementation, test, documentation, packaging, and code-quality checklist.\\n+\\n+### List\\n+\\n+Read `references/commands/list.md`. Discover installed and generated CLI-Anything tools\\n+and support human-readable or JSON output as requested.\\n+\\n+## Condensed Fallback Rules\\n+\\n+Use these only when the full methodology cannot be retrieved.\\n+\\n+### Harness Structure\\n+\\n+Produce:\\n \\n ```text\\n <software>/\\n@@ -42,63 +116,33 @@ Produce this structure:\\n └── tests/\\n ```\\n \\n-Implement a stateful Click CLI with:\\n-\\n-- one-shot subcommands\\n-- REPL mode as the default when no subcommand is given\\n-- `--json` machine-readable output\\n-- session state with undo/redo where the target software supports it\\n-\\n-### Refine\\n-\\n-Use when the harness already exists.\\n-\\n-First inventory current commands and tests, then do gap analysis against the target software. Prefer:\\n-\\n-- high-impact missing features\\n-- easy wrappers around existing backend APIs or CLIs\\n-- additions that compose well with existing commands\\n-\\n-Do not remove existing commands unless the user explicitly asks for a breaking change.\\n-\\n-### Test\\n-\\n-Plan tests before writing them. Keep both:\\n-\\n-- `test_core.py` for unit coverage\\n-- `test_full_e2e.py` for workflow and backend validation\\n-\\n-When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\\n-\\n-### Validate\\n-\\n-Check that the harness:\\n-\\n-- uses the `cli_anything.<software>` namespace package layout\\n-- has an installable `setup.py` entry point\\n-- supports JSON output\\n-- has a REPL default path\\n-- documents usage and tests\\n-\\n-## Backend Rules\\n-\\n-Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\\n-\\n-## Packaging Rules\\n-\\n-- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`\\n-- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\\n-- Expose `cli-anything-<software>` through `console_scripts`\\n-\\n-## Workflow\\n-\\n-1. Acquire the source tree locally.\\n-2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\\n-3. Design command groups and state model.\\n-4. Implement the harness.\\n-5. Write `TEST.md`, then tests, then run them.\\n-6. Update README usage docs.\\n-7. Verify local installation with `pip install -e .`\\n+### Required Behavior\\n+\\n+- Prefer the real software backend over reimplementation.\\n+- Provide one-shot Click subcommands and default REPL mode.\\n+- Support `--json` machine-readable output.\\n+- Add session state with undo/redo where the target supports it.\\n+- Auto-save one-shot session mutations and support `--dry-run`.\\n+- Use locked session-file writes to avoid concurrent JSON corruption.\\n+- Copy and use the unified `ReplSkin`.\\n+- Add truthful preview commands for software with meaningful visual or inspection state.\\n+- Generate both canonical and packaged CLI-specific `SKILL.md` files.\\n+\\n+### Testing\\n+\\n+- Write `TEST.md` before test code.\\n+- Keep `test_core.py` for unit coverage.\\n+- Keep `test_full_e2e.py` for real-file workflows and real backend validation.\\n+- Verify rendered/exported output programmatically, not only process exit codes.\\n+- Test the installed `cli-anything-<software>` command via `_resolve_cli()`.\\n+- Run release validation with `CLI_ANYTHING_FORCE_INSTALLED=1`.\\n+\\n+### Packaging\\n+\\n+- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`.\\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`.\\n+- Expose `cli-anything-<software>` through `console_scripts`.\\n+- Include the packaged CLI-specific `skills/SKILL.md`.\\n \\n ## Output Expectations\\n \\n\"\n },\n {\n \"comment\": \"The markdown tables use `||` at the start of each row, which renders as an extra empty first column in most Markdown parsers (and can break table formatting in some renderers). Change these to standard table syntax with a single leading `|` per row (e.g., `| Path | Purpose |`) to ensure consistent rendering.\",\n \"path\": \"codex-skill/SKILL.md\",\n \"hunk\": \"@@ -1,13 +1,57 @@\\n ---\\n name: cli-anything\\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\\n ---\\n \\n # CLI-Anything for Codex\\n \\n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\\n \\n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\\n+## Read the Full Methodology First\\n+\\n+Before implementation, use the full methodology source of truth:\\n+\\n+1. Read `references/HARNESS.md` relative to this skill directory.\\n+2. Read the matching mode specification under `references/commands/`.\\n+3. Read referenced files under `references/guides/` only when they apply to the target.\\n+4. If the installed resources are unavailable and this skill is being used from a\\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\\n+ the resources around it.\\n+5. If neither local source is available, clone or download\\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\\n+\\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\\n+skill so a normal Codex installation is self-contained.\\n+\\n+## Resource Map\\n+\\n+| Path | Purpose |\\n+|------|---------|\\n+| `references/HARNESS.md` | Complete methodology and quality rules |\\n+| `references/commands/cli-anything.md` | Build-mode specification |\\n+| `references/commands/refine.md` | Refine-mode specification |\\n+| `references/commands/test.md` | Test-mode specification |\\n+| `references/commands/validate.md` | Validation checklist |\\n+| `references/commands/list.md` | Installed/generated harness discovery |\\n+| `references/guides/` | On-demand implementation guidance |\\n+| `scripts/repl_skin.py` | Copy into generated harnesses as `utils/repl_skin.py` |\\n+| `scripts/preview_bundle.py` | Copy into preview-capable harnesses as `utils/preview_bundle.py` |\\n+| `scripts/skill_generator.py` | Generate canonical and packaged CLI skills |\\n+| `assets/SKILL.md.template` | Skill generation template |\\n+| `references/docs/PREVIEW_PROTOCOL.md` | Shared preview bundle protocol |\\n+\\n+When reading vendored documents, apply these path remappings instead of resolving\\n+plugin paths against the current working directory:\\n+\\n+| Document reference | Installed skill path |\\n+|--------------------|----------------------|\\n+| `guides/...` | `references/guides/...` |\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/SKILL.md b/codex-skill/SKILL.md\\nindex 5d674e1603..c8f8ac1380 100644\\n--- a/codex-skill/SKILL.md\\n+++ b/codex-skill/SKILL.md\\n@@ -1,13 +1,57 @@\\n ---\\n name: cli-anything\\n-description: Use when the user wants Codex to build, refine, test, or validate a CLI-Anything harness for a GUI application or source repository. Adapts the CLI-Anything methodology to Codex without changing the generated Python harness format.\\n+description: Use when the user wants Codex to build, refine, test, validate, or list CLI-Anything harnesses for GUI applications or source repositories. Adapts the full CLI-Anything methodology to Codex without changing the generated Python harness format.\\n ---\\n \\n # CLI-Anything for Codex\\n \\n Use this skill when the user wants Codex to act like the `CLI-Anything` builder.\\n \\n-If this skill is being used from inside the `CLI-Anything` repository, read `../cli-anything-plugin/HARNESS.md` before implementation. That file is the full methodology source of truth. If it is not available, follow the condensed rules below.\\n+## Read the Full Methodology First\\n+\\n+Before implementation, use the full methodology source of truth:\\n+\\n+1. Read `references/HARNESS.md` relative to this skill directory.\\n+2. Read the matching mode specification under `references/commands/`.\\n+3. Read referenced files under `references/guides/` only when they apply to the target.\\n+4. If the installed resources are unavailable and this skill is being used from a\\n+ `CLI-Anything` repository checkout, read `../cli-anything-plugin/HARNESS.md` and\\n+ the resources around it.\\n+5. If neither local source is available, clone or download\\n+ `https://github.com/HKUDS/CLI-Anything` and use `cli-anything-plugin/HARNESS.md`.\\n+6. Only if all full-methodology sources are unavailable, follow the condensed rules below.\\n+\\n+The installer vendors the canonical resources from `cli-anything-plugin/` into this\\n+skill so a normal Codex installation is self-contained.\\n+\\n+## Resource Map\\n+\\n+| Path | Purpose |\\n+|------|---------|\\n+| `references/HARNESS.md` | Complete methodology and quality rules |\\n+| `references/commands/cli-anything.md` | Build-mode specification |\\n+| `references/commands/refine.md` | Refine-mode specification |\\n+| `references/commands/test.md` | Test-mode specification |\\n+| `references/commands/validate.md` | Validation checklist |\\n+| `references/commands/list.md` | Installed/generated harness discovery |\\n+| `references/guides/` | On-demand implementation guidance |\\n+| `scripts/repl_skin.py` | Copy into generated harnesses as `utils/repl_skin.py` |\\n+| `scripts/preview_bundle.py` | Copy into preview-capable harnesses as `utils/preview_bundle.py` |\\n+| `scripts/skill_generator.py` | Generate canonical and packaged CLI skills |\\n+| `scripts/templates/SKILL.md.template` | Skill generation template used by `skill_generator.py` |\\n+| `references/docs/PREVIEW_PROTOCOL.md` | Shared preview bundle protocol |\\n+\\n+When reading vendored documents, apply these path remappings instead of resolving\\n+plugin paths against the current working directory:\\n+\\n+| Document reference | Installed skill path |\\n+|--------------------|----------------------|\\n+| `guides/...` | `references/guides/...` |\\n+| `cli-anything-plugin/repl_skin.py` | `scripts/repl_skin.py` |\\n+| `cli-anything-plugin/preview_bundle.py` | `scripts/preview_bundle.py` |\\n+| `cli-anything-plugin/skill_generator.py` | `scripts/skill_generator.py` |\\n+| `templates/SKILL.md.template` | `scripts/templates/SKILL.md.template` |\\n+| `docs/PREVIEW_PROTOCOL.md` | `references/docs/PREVIEW_PROTOCOL.md` |\\n \\n ## Inputs\\n \\n@@ -22,9 +66,39 @@ Derive the software name from the local directory name after cloning if needed.\\n \\n ### Build\\n \\n-Use when the user wants a new harness.\\n+Read `references/commands/cli-anything.md`. Build a complete harness through source\\n+analysis, architecture design, implementation, test planning, test implementation,\\n+test documentation, CLI-specific `SKILL.md` generation, and local installation.\\n \\n-Produce this structure:\\n+### Refine\\n+\\n+Read `references/commands/refine.md`. Inventory current commands and tests, compare\\n+them against the target software, then incrementally add high-impact capabilities\\n+without removing existing commands unless the user requests a breaking change.\\n+\\n+### Test\\n+\\n+Read `references/commands/test.md`. Run the harness tests against the real backend,\\n+verify installed-command subprocess coverage, and update `TEST.md` only with passing\\n+results.\\n+\\n+### Validate\\n+\\n+Read `references/commands/validate.md`. Validate the harness against the complete\\n+directory, implementation, test, documentation, packaging, and code-quality checklist.\\n+\\n+### List\\n+\\n+Read `references/commands/list.md`. Discover installed and generated CLI-Anything tools\\n+and support human-readable or JSON output as requested.\\n+\\n+## Condensed Fallback Rules\\n+\\n+Use these only when the full methodology cannot be retrieved.\\n+\\n+### Harness Structure\\n+\\n+Produce:\\n \\n ```text\\n <software>/\\n@@ -42,63 +116,33 @@ Produce this structure:\\n └── tests/\\n ```\\n \\n-Implement a stateful Click CLI with:\\n-\\n-- one-shot subcommands\\n-- REPL mode as the default when no subcommand is given\\n-- `--json` machine-readable output\\n-- session state with undo/redo where the target software supports it\\n-\\n-### Refine\\n-\\n-Use when the harness already exists.\\n-\\n-First inventory current commands and tests, then do gap analysis against the target software. Prefer:\\n-\\n-- high-impact missing features\\n-- easy wrappers around existing backend APIs or CLIs\\n-- additions that compose well with existing commands\\n-\\n-Do not remove existing commands unless the user explicitly asks for a breaking change.\\n-\\n-### Test\\n-\\n-Plan tests before writing them. Keep both:\\n-\\n-- `test_core.py` for unit coverage\\n-- `test_full_e2e.py` for workflow and backend validation\\n-\\n-When possible, test the installed command via subprocess using `cli-anything-<software>` rather than only module imports.\\n-\\n-### Validate\\n-\\n-Check that the harness:\\n-\\n-- uses the `cli_anything.<software>` namespace package layout\\n-- has an installable `setup.py` entry point\\n-- supports JSON output\\n-- has a REPL default path\\n-- documents usage and tests\\n-\\n-## Backend Rules\\n-\\n-Prefer the real software backend over reimplementation. Wrap the actual executable or scripting interface in `utils/<software>_backend.py` when possible. Use synthetic reimplementation only when the project explicitly requires it or no viable native backend exists.\\n-\\n-## Packaging Rules\\n-\\n-- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`\\n-- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`\\n-- Expose `cli-anything-<software>` through `console_scripts`\\n-\\n-## Workflow\\n-\\n-1. Acquire the source tree locally.\\n-2. Analyze architecture, data model, existing CLIs, and GUI-to-API mappings.\\n-3. Design command groups and state model.\\n-4. Implement the harness.\\n-5. Write `TEST.md`, then tests, then run them.\\n-6. Update README usage docs.\\n-7. Verify local installation with `pip install -e .`\\n+### Required Behavior\\n+\\n+- Prefer the real software backend over reimplementation.\\n+- Provide one-shot Click subcommands and default REPL mode.\\n+- Support `--json` machine-readable output.\\n+- Add session state with undo/redo where the target supports it.\\n+- Auto-save one-shot session mutations and support `--dry-run`.\\n+- Use locked session-file writes to avoid concurrent JSON corruption.\\n+- Copy and use the unified `ReplSkin`.\\n+- Add truthful preview commands for software with meaningful visual or inspection state.\\n+- Generate both canonical and packaged CLI-specific `SKILL.md` files.\\n+\\n+### Testing\\n+\\n+- Write `TEST.md` before test code.\\n+- Keep `test_core.py` for unit coverage.\\n+- Keep `test_full_e2e.py` for real-file workflows and real backend validation.\\n+- Verify rendered/exported output programmatically, not only process exit codes.\\n+- Test the installed `cli-anything-<software>` command via `_resolve_cli()`.\\n+- Run release validation with `CLI_ANYTHING_FORCE_INSTALLED=1`.\\n+\\n+### Packaging\\n+\\n+- Use `find_namespace_packages(include=[\\\"cli_anything.*\\\"])`.\\n+- Keep `cli_anything/` as a namespace package without a top-level `__init__.py`.\\n+- Expose `cli-anything-<software>` through `console_scripts`.\\n+- Include the packaged CLI-specific `skills/SKILL.md`.\\n \\n ## Output Expectations\\n \\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Place the vendored skill template where the generator loads it**\\n\\nWhen the installed skill later uses the vendored `scripts/skill_generator.py` with its default settings, the generator looks for `Path(__file__).parent / \\\"templates\\\" / \\\"SKILL.md.template\\\"`, i.e. `scripts/templates/SKILL.md.template` after installation. This line copies the template only to `assets/`, so the default template is never found and generation silently falls back to the simpler non-canonical output whenever Jinja2 is available and no custom template path is passed. Copy the template to the path the generator expects, or adjust the vendored generator to look in `assets/`.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"codex-skill/scripts/install.sh\",\n \"hunk\": \"@@ -15,7 +31,30 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+}\\n+trap cleanup EXIT\\n+\\n+cp -R \\\"${SKILL_DIR}\\\" \\\"${STAGING_DIR}\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/assets\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\\n+cp \\\"${PLUGIN_DIR}/repl_skin.py\\\" \\\"${STAGING_DIR}/scripts/repl_skin.py\\\"\\n+cp \\\"${PLUGIN_DIR}/preview_bundle.py\\\" \\\"${STAGING_DIR}/scripts/preview_bundle.py\\\"\\n+cp \\\"${PLUGIN_DIR}/skill_generator.py\\\" \\\"${STAGING_DIR}/scripts/skill_generator.py\\\"\\n+cp \\\"${PLUGIN_DIR}/templates/\\\"* \\\"${STAGING_DIR}/assets/\\\"\",\n \"resolving_sha\": \"96a4983e77439924765222dfd3103139627ae0c1\",\n \"resolving_diff\": \"diff --git a/codex-skill/scripts/install.sh b/codex-skill/scripts/install.sh\\nindex aa14514d8c..0646e3f460 100755\\n--- a/codex-skill/scripts/install.sh\\n+++ b/codex-skill/scripts/install.sh\\n@@ -4,8 +4,24 @@ set -euo pipefail\\n \\n SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n SKILL_DIR=\\\"$(cd \\\"${SCRIPT_DIR}/..\\\" && pwd)\\\"\\n+REPO_ROOT=\\\"$(cd \\\"${SKILL_DIR}/..\\\" && pwd)\\\"\\n+PLUGIN_DIR=\\\"${REPO_ROOT}/cli-anything-plugin\\\"\\n+PREVIEW_PROTOCOL=\\\"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\\\"\\n DEST_ROOT=\\\"${CODEX_HOME:-$HOME/.codex}/skills\\\"\\n DEST_DIR=\\\"${DEST_ROOT}/cli-anything\\\"\\n+STAGING_DIR=\\\"\\\"\\n+\\n+if [[ ! -f \\\"${PLUGIN_DIR}/HARNESS.md\\\" ]]; then\\n+ echo \\\"Cannot find canonical CLI-Anything resources at: ${PLUGIN_DIR}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n+\\n+if [[ ! -f \\\"${PREVIEW_PROTOCOL}\\\" ]]; then\\n+ echo \\\"Cannot find preview protocol at: ${PREVIEW_PROTOCOL}\\\" >&2\\n+ echo \\\"Run this installer from a full CLI-Anything repository checkout.\\\" >&2\\n+ exit 1\\n+fi\\n \\n mkdir -p \\\"${DEST_ROOT}\\\"\\n \\n@@ -15,7 +31,32 @@ if [[ -e \\\"${DEST_DIR}\\\" ]]; then\\n exit 1\\n fi\\n \\n-cp -R \\\"${SKILL_DIR}\\\" \\\"${DEST_DIR}\\\"\\n+cleanup() {\\n+ if [[ -n \\\"${STAGING_DIR}\\\" && -d \\\"${STAGING_DIR}\\\" ]]; then\\n+ rm -rf \\\"${STAGING_DIR}\\\"\\n+ fi\\n+}\\n+trap cleanup EXIT\\n+\\n+STAGING_DIR=\\\"$(mktemp -d \\\"${DEST_ROOT}/.cli-anything.tmp.XXXXXX\\\")\\\"\\n+cp -R \\\"${SKILL_DIR}/.\\\" \\\"${STAGING_DIR}/\\\"\\n+mkdir -p \\\\\\n+ \\\"${STAGING_DIR}/references/commands\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/docs\\\" \\\\\\n+ \\\"${STAGING_DIR}/references/guides\\\" \\\\\\n+ \\\"${STAGING_DIR}/scripts/templates\\\"\\n+\\n+cp \\\"${PLUGIN_DIR}/HARNESS.md\\\" \\\"${STAGING_DIR}/references/HARNESS.md\\\"\\n+cp \\\"${PLUGIN_DIR}/commands/\\\"*.md \\\"${STAGING_DIR}/references/commands/\\\"\\n+cp \\\"${PLUGIN_DIR}/guides/\\\"*.md \\\"${STAGING_DIR}/references/guides/\\\"\\n+cp \\\"${PLUGIN_DIR}/repl_skin.py\\\" \\\"${STAGING_DIR}/scripts/repl_skin.py\\\"\\n+cp \\\"${PLUGIN_DIR}/preview_bundle.py\\\" \\\"${STAGING_DIR}/scripts/preview_bundle.py\\\"\\n+cp \\\"${PLUGIN_DIR}/skill_generator.py\\\" \\\"${STAGING_DIR}/scripts/skill_generator.py\\\"\\n+cp \\\"${PLUGIN_DIR}/templates/\\\"* \\\"${STAGING_DIR}/scripts/templates/\\\"\\n+cp \\\"${PREVIEW_PROTOCOL}\\\" \\\"${STAGING_DIR}/references/docs/PREVIEW_PROTOCOL.md\\\"\\n+\\n+mv \\\"${STAGING_DIR}\\\" \\\"${DEST_DIR}\\\"\\n \\n echo \\\"Installed Codex skill to: ${DEST_DIR}\\\"\\n+echo \\\"Vendored CLI-Anything methodology resources into the installed skill.\\\"\\n echo \\\"Restart Codex to pick up the new skill.\\\"\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":"diff --git a/codex-skill/tests/test_install.sh b/codex-skill/tests/test_install.sh\nnew file mode 100755\nindex 0000000000..e7170193bc\n--- /dev/null\n+++ b/codex-skill/tests/test_install.sh\n@@ -0,0 +1,92 @@\n+#!/usr/bin/env bash\n+\n+set -euo pipefail\n+\n+SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n+SKILL_DIR=\"$(cd \"${SCRIPT_DIR}/..\" && pwd)\"\n+REPO_ROOT=\"$(cd \"${SKILL_DIR}/..\" && pwd)\"\n+PLUGIN_DIR=\"${REPO_ROOT}/cli-anything-plugin\"\n+TMP_DIR=\"$(mktemp -d)\"\n+CODEX_HOME=\"${TMP_DIR}/codex-home\"\n+INSTALLED_DIR=\"${CODEX_HOME}/skills/cli-anything\"\n+STALE_STAGING_DIR=\"${CODEX_HOME}/skills/.cli-anything.tmp.stale\"\n+\n+cleanup() {\n+ rm -rf \"${TMP_DIR}\"\n+}\n+trap cleanup EXIT\n+\n+fail() {\n+ echo \"FAIL: $*\" >&2\n+ exit 1\n+}\n+\n+assert_file() {\n+ [[ -f \"$1\" ]] || fail \"expected file: $1\"\n+}\n+\n+assert_same() {\n+ cmp -s \"$1\" \"$2\" || fail \"files differ: $1 $2\"\n+}\n+\n+assert_tree_same() {\n+ diff -qr \"$1\" \"$2\" >/dev/null || fail \"directories differ: $1 $2\"\n+}\n+\n+mkdir -p \"${STALE_STAGING_DIR}/codex-skill\"\n+echo \"left over from an interrupted install\" > \"${STALE_STAGING_DIR}/codex-skill/stale.txt\"\n+\n+CODEX_HOME=\"${CODEX_HOME}\" bash \"${SKILL_DIR}/scripts/install.sh\"\n+\n+assert_file \"${INSTALLED_DIR}/SKILL.md\"\n+[[ -d \"${STALE_STAGING_DIR}\" ]] ||\n+ fail \"installer reused or removed the stale staging directory\"\n+[[ ! -d \"${INSTALLED_DIR}/codex-skill\" ]] ||\n+ fail \"installer created a nested codex-skill directory\"\n+assert_file \"${INSTALLED_DIR}/references/HARNESS.md\"\n+assert_file \"${INSTALLED_DIR}/references/commands/cli-anything.md\"\n+assert_file \"${INSTALLED_DIR}/references/commands/refine.md\"\n+assert_file \"${INSTALLED_DIR}/references/commands/test.md\"\n+assert_file \"${INSTALLED_DIR}/references/commands/validate.md\"\n+assert_file \"${INSTALLED_DIR}/references/commands/list.md\"\n+assert_file \"${INSTALLED_DIR}/references/guides/auto-save-dry-run.md\"\n+assert_file \"${INSTALLED_DIR}/references/guides/session-locking.md\"\n+assert_file \"${INSTALLED_DIR}/references/guides/preview-methodology.md\"\n+assert_file \"${INSTALLED_DIR}/scripts/repl_skin.py\"\n+assert_file \"${INSTALLED_DIR}/scripts/preview_bundle.py\"\n+assert_file \"${INSTALLED_DIR}/scripts/skill_generator.py\"\n+assert_file \"${INSTALLED_DIR}/scripts/templates/SKILL.md.template\"\n+assert_file \"${INSTALLED_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+\n+assert_same \"${PLUGIN_DIR}/HARNESS.md\" \"${INSTALLED_DIR}/references/HARNESS.md\"\n+assert_same \"${PLUGIN_DIR}/repl_skin.py\" \"${INSTALLED_DIR}/scripts/repl_skin.py\"\n+assert_same \"${PLUGIN_DIR}/preview_bundle.py\" \"${INSTALLED_DIR}/scripts/preview_bundle.py\"\n+assert_same \"${PLUGIN_DIR}/skill_generator.py\" \"${INSTALLED_DIR}/scripts/skill_generator.py\"\n+assert_same \"${REPO_ROOT}/docs/PREVIEW_PROTOCOL.md\" \"${INSTALLED_DIR}/references/docs/PREVIEW_PROTOCOL.md\"\n+assert_tree_same \"${PLUGIN_DIR}/commands\" \"${INSTALLED_DIR}/references/commands\"\n+assert_tree_same \"${PLUGIN_DIR}/guides\" \"${INSTALLED_DIR}/references/guides\"\n+assert_tree_same \"${PLUGIN_DIR}/templates\" \"${INSTALLED_DIR}/scripts/templates\"\n+\n+python3 -m py_compile \\\n+ \"${INSTALLED_DIR}/scripts/repl_skin.py\" \\\n+ \"${INSTALLED_DIR}/scripts/preview_bundle.py\" \\\n+ \"${INSTALLED_DIR}/scripts/skill_generator.py\"\n+\n+if CODEX_HOME=\"${CODEX_HOME}\" bash \"${SKILL_DIR}/scripts/install.sh\" >/dev/null 2>&1; then\n+ fail \"installer overwrote an existing skill\"\n+fi\n+\n+grep -q 'references/HARNESS.md' \"${INSTALLED_DIR}/SKILL.md\" ||\n+ fail \"installed SKILL.md does not point to vendored HARNESS.md\"\n+\n+DETACHED_ROOT=\"${TMP_DIR}/detached\"\n+DETACHED_LOG=\"${TMP_DIR}/detached-install.log\"\n+mkdir -p \"${DETACHED_ROOT}\"\n+cp -R \"${SKILL_DIR}\" \"${DETACHED_ROOT}/codex-skill\"\n+if CODEX_HOME=\"${TMP_DIR}/detached-home\" bash \"${DETACHED_ROOT}/codex-skill/scripts/install.sh\" >\"${DETACHED_LOG}\" 2>&1; then\n+ fail \"installer accepted a detached skill without canonical resources\"\n+fi\n+grep -q 'Cannot find canonical CLI-Anything resources' \"${DETACHED_LOG}\" ||\n+ fail \"detached install did not explain the missing canonical resources\"\n+\n+echo \"PASS: Codex skill installer vendors the complete CLI-Anything resource set.\"\n"},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4835,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":337,"string":"337"},"task_type":{"kind":"string","value":"issue_to_patch"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"feat: add WaveTone CLI harness"},"pr_body":{"kind":"string","value":"Fork of CLI-Anything for contributing a WaveTone 2.61 CLI harness that creates JSON audio transcription manifests, probes audio metadata, manages labels and tempo settings, and launches the real Windows WaveTone executable for agent-assisted workflows."},"base_sha":{"kind":"string","value":"ea9a79dfa1d7f10c1eef0397e17a1660c245b476"},"head_sha":{"kind":"string","value":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b"},"gold_diff":{"kind":"string","value":"diff --git a/.gitignore b/.gitignore\nindex 842522adb..85070db1d 100644\n--- a/.gitignore\n+++ b/.gitignore\n@@ -208,6 +208,8 @@\n !/blender/agent-harness/\n !/inkscape/agent-harness/\n !/audacity/agent-harness/\n+!/wavetone/\n+!/wavetone/agent-harness/\n !/libreoffice/agent-harness/\n !/zotero/agent-harness/\n !/mubu/agent-harness/\ndiff --git a/README.md b/README.md\nindex 17a93d0dd..509e6536b 100644\n--- a/README.md\n+++ b/README.md\n@@ -667,7 +667,7 @@ The meta-skill points agents to the live CLI-Hub catalog, where they can choose\n | **🤖 AI/ML Platforms** | Automate model training, inference pipelines, and hyperparameter tuning through structured commands | Stable Diffusion WebUI, ComfyUI, Ollama, InvokeAI, Text-generation-webui, Open WebUI, Fooocus, Kohya_ss, AnythingLLM, SillyTavern |\n | **📊 Data & Analytics** | Enable programmatic data processing, visualization, and statistical analysis workflows | JupyterLab, Apache Superset, Metabase, Redash, DBeaver, KNIME, Orange, OpenSearch Dashboards, Lightdash |\n | **💻 Development Tools** | Streamline code editing, building, testing, and deployment processes via command interfaces | Jenkins, Gitea, Hoppscotch, Portainer, pgAdmin, SonarQube, ArgoCD, OpenLens, Insomnia, Beekeeper Studio, **[iTerm2](https://iterm2.com)** |\n-| **🎨 Creative & Media** | Control content creation, editing, and rendering workflows programmatically | Blender, GIMP, OBS Studio, Audacity, Krita, Kdenlive, Shotcut, Inkscape, Darktable, LMMS, Ardour |\n+| **🎨 Creative & Media** | Control content creation, editing, and rendering workflows programmatically | Blender, GIMP, OBS Studio, Audacity, WaveTone, Krita, Kdenlive, Shotcut, Inkscape, Darktable, LMMS, Ardour |\n | **🎮 Game Development** | Manage game projects, scenes, exports, and scripting through headless engine interfaces | **[Godot Engine](https://godotengine.org)**, **[s&box](https://sbox.game)** |\n | **🔬 Scientific Computing** | Automate research workflows, simulations, and complex calculations | ImageJ, FreeCAD, QGIS, ParaView, Gephi, LibreCAD, Stellarium, KiCad, JASP, Jamovi |\n | **🏢 Enterprise & Office** | Convert business applications and productivity tools into agent-accessible systems | NextCloud, GitLab, Grafana, Mattermost, LibreOffice, AppFlowy, NocoDB, Odoo (Community), Plane, ERPNext |\n@@ -943,6 +943,13 @@ Each application received complete, production-ready CLI interfaces — not demo\n <td align=\"center\">✅ 161</td>\n </tr>\n <tr>\n+<td align=\"center\"><strong>WaveTone</strong></td>\n+<td>Audio Transcription</td>\n+<td><code>cli-anything-wavetone</code></td>\n+<td>JSON manifest + real WaveTone launch</td>\n+<td align=\"center\"><a href=\"wavetone/agent-harness/\">New</a></td>\n+</tr>\n+<tr>\n <td align=\"center\"><strong>🌐 Browser</strong></td>\n <td>Browser Automation</td>\n <td><code>cli-anything-browser</code></td>\n@@ -1221,6 +1228,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\n blender 208 passed ✅ (150 unit + 58 e2e)\n inkscape 202 passed ✅ (148 unit + 54 e2e)\n audacity 161 passed ✅ (107 unit + 54 e2e)\n+wavetone 30 passed ✅ (24 unit + 6 default e2e, 2 backend-gated e2e skipped; 32 passed opt-in)\n libreoffice 158 passed ✅ (89 unit + 69 e2e)\n mubu 96 passed ✅ (85 unit + 11 e2e)\n obs-studio 153 passed ✅ (116 unit + 37 e2e)\n@@ -1300,6 +1308,7 @@ cli-anything/\n ├── 🧊 blender/agent-harness/ # Blender CLI (208 tests)\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI (202 tests)\n ├── 🎵 audacity/agent-harness/ # Audacity CLI (161 tests)\n+├── wavetone/agent-harness/ # WaveTone CLI (32 tests: 30 default + 2 backend-gated e2e)\n ├── 🌐 browser/agent-harness/ # Browser CLI (DOMShell MCP, new)\n ├── 📄 libreoffice/agent-harness/ # LibreOffice CLI (158 tests)\n ├── 📧 mailchimp/agent-harness/ # Mailchimp Marketing API CLI (303 commands, 36 unit tests)\ndiff --git a/README_CN.md b/README_CN.md\nindex ffac02dd9..6434d70e0 100644\n--- a/README_CN.md\n+++ b/README_CN.md\n@@ -368,7 +368,7 @@ cli-anything-gimp\n | **🤖 AI/ML 平台** | 用结构化命令驱动模型训练、推理流水线和超参搜索 | Stable Diffusion WebUI、ComfyUI、InvokeAI、Text-generation-webui、Open WebUI、Fooocus、Kohya_ss、AnythingLLM、SillyTavern |\n | **📊 数据与分析** | 以编程方式完成数据处理、可视化和统计分析工作流 | JupyterLab、Apache Superset、Metabase、Redash、DBeaver、KNIME、Orange、OpenSearch Dashboards、Lightdash |\n | **💻 开发工具** | 通过 CLI 串联代码编辑、构建、测试与部署流程 | Jenkins、Gitea、Hoppscotch、Portainer、pgAdmin、SonarQube、ArgoCD、OpenLens、Insomnia、Beekeeper Studio |\n-| **🎨 创意与媒体** | 以编程方式控制内容创作、编辑和渲染工作流 | Blender、GIMP、OBS Studio、Audacity、Krita、Kdenlive、Shotcut、Inkscape、Darktable、LMMS、Ardour |\n+| **🎨 创意与媒体** | 以编程方式控制内容创作、编辑和渲染工作流 | Blender、GIMP、OBS Studio、Audacity、WaveTone、Krita、Kdenlive、Shotcut、Inkscape、Darktable、LMMS、Ardour |\n | **📐 图表与可视化** | 以编程方式创建和操作流程图、架构图、ER 图等各类图表 | Draw.io (diagrams.net)、Mermaid、PlantUML、Excalidraw、yEd |\n | **🔬 科学计算** | 自动化科研工作流、仿真模拟和复杂计算 | ImageJ、FreeCAD、QGIS、ParaView、Gephi、LibreCAD、Stellarium、KiCad、JASP、Jamovi |\n | **🏢 企业与办公** | 将商业应用和生产力工具转化为 Agent 可访问的系统 | NextCloud、GitLab、Grafana、Mattermost、LibreOffice、AppFlowy、NocoDB、Odoo (Community)、Plane、ERPNext |\n@@ -534,6 +534,13 @@ CLI-Anything 适用于任何有代码库的软件 —— 不限领域，不限\n <td align=\"center\">✅ 161</td>\n </tr>\n <tr>\n+<td align=\"center\"><strong>WaveTone</strong></td>\n+<td>音频扒谱辅助</td>\n+<td><code>cli-anything-wavetone</code></td>\n+<td>JSON manifest + real WaveTone launch</td>\n+<td align=\"center\"><a href=\"wavetone/agent-harness/\">新增</a></td>\n+</tr>\n+<tr>\n <td align=\"center\"><strong>📄 LibreOffice</strong></td>\n <td>办公套件（Writer、Calc、Impress）</td>\n <td><code>cli-anything-libreoffice</code></td>\n@@ -672,6 +679,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\n blender 208 passed ✅ (150 unit + 58 e2e)\n inkscape 202 passed ✅ (148 unit + 54 e2e)\n audacity 161 passed ✅ (107 unit + 54 e2e)\n+wavetone 30 passed ✅ (24 unit + 6 default e2e，2 backend-gated e2e skipped；32 passed opt-in)\n libreoffice 158 passed ✅ (89 unit + 69 e2e)\n obs-studio 153 passed ✅ (116 unit + 37 e2e)\n kdenlive 155 passed ✅ (111 unit + 44 e2e)\n@@ -745,6 +753,7 @@ cli-anything/\n ├── 🧊 blender/agent-harness/ # Blender CLI（208 项测试）\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI（202 项测试）\n ├── 🎵 audacity/agent-harness/ # Audacity CLI（161 项测试）\n+├── wavetone/agent-harness/ # WaveTone CLI（32 项测试：30 default + 2 backend-gated e2e）\n ├── 📄 libreoffice/agent-harness/ # LibreOffice CLI（158 项测试）\n ├── 📚 zotero/agent-harness/ # Zotero CLI（新增，支持文献导入）\n ├── 📓 joplin/agent-harness/ # Joplin CLI（134 测试：107 单元 + 27 e2e）\ndiff --git a/registry.json b/registry.json\nindex 3f3e8ce34..77041f8b8 100644\n--- a/registry.json\n+++ b/registry.json\n@@ -100,6 +100,25 @@\n }\n ]\n },\n+ {\n+ \"name\": \"wavetone\",\n+ \"display_name\": \"WaveTone\",\n+ \"version\": \"1.0.0\",\n+ \"description\": \"Prepare WaveTone 2.61 audio transcription manifests, probe audio files, and launch the real Windows WaveTone executable\",\n+ \"requires\": \"WaveTone 2.61 extracted on Windows; set WAVETONE_EXE or WAVETONE_HOME\",\n+ \"homepage\": \"http://ackiesound.ifdef.jp/\",\n+ \"source_url\": null,\n+ \"install_cmd\": \"pip install git+https://github.com/HKUDS/CLI-Anything.git#subdirectory=wavetone/agent-harness\",\n+ \"entry_point\": \"cli-anything-wavetone\",\n+ \"skill_md\": \"skills/cli-anything-wavetone/SKILL.md\",\n+ \"category\": \"audio\",\n+ \"contributors\": [\n+ {\n+ \"name\": \"Shuhan Zhang\",\n+ \"url\": \"https://github.com/Manifold68575\"\n+ }\n+ ]\n+ },\n {\n \"name\": \"blender\",\n \"display_name\": \"Blender\",\ndiff --git a/skills/cli-anything-wavetone/SKILL.md b/skills/cli-anything-wavetone/SKILL.md\nnew file mode 100644\nindex 000000000..a565109ed\n--- /dev/null\n+++ b/skills/cli-anything-wavetone/SKILL.md\n@@ -0,0 +1,53 @@\n+---\n+name: \"cli-anything-wavetone\"\n+description: \"Control WaveTone 2.61 workflows through a JSON manifest and launch the real Windows WaveTone executable.\"\n+---\n+\n+# cli-anything-wavetone\n+\n+Use this skill when an agent needs to prepare, inspect, and launch WaveTone 2.61\n+audio transcription workflows.\n+\n+## Requirements\n+\n+- Windows host.\n+- WaveTone 2.61 extracted locally.\n+- Set `WAVETONE_EXE` to `wavetone.exe` or `WAVETONE_HOME` to the extracted\n+ WaveTone directory when the default portable path is not used.\n+\n+## Core Commands\n+\n+All commands support the top-level `--json` flag.\n+\n+```bash\n+cli-anything-wavetone --json wavetone doctor\n+cli-anything-wavetone --json project new input.wav -o project.wt.json\n+cli-anything-wavetone --project project.wt.json --json audio probe\n+cli-anything-wavetone --project project.wt.json --json project set-tempo --bpm 120 --meter 4/4\n+cli-anything-wavetone --project project.wt.json --json project add-label chorus --time 64.0\n+cli-anything-wavetone --project project.wt.json --json wavetone launch\n+```\n+\n+## Command Groups\n+\n+- `project`: create manifests, set tempo, add labels, update intended analysis\n+ settings, and attach a WFD saved from WaveTone.\n+- `audio`: probe audio metadata before opening it in WaveTone.\n+- `wavetone`: run `doctor`, list supported formats, or launch the real GUI.\n+- `session`: record lightweight event logs for multi-step agent workflows.\n+- `defaults`: show default analysis settings.\n+\n+## Agent Guidance\n+\n+The JSON project manifest is not a WaveTone WFD file. It is an agent-facing plan\n+for the source audio, intended analysis settings, labels, and tempo metadata.\n+Use WaveTone itself to perform analysis and save WFD/MIDI/text/WAVE outputs.\n+\n+When running in automated checks, use:\n+\n+```bash\n+cli-anything-wavetone --json wavetone launch input.wav --wait 1 --terminate\n+```\n+\n+This confirms that the real backend can be started without leaving a persistent\n+GUI process behind.\ndiff --git a/wavetone/agent-harness/WAVETONE.md b/wavetone/agent-harness/WAVETONE.md\nnew file mode 100644\nindex 000000000..112080e0c\n--- /dev/null\n+++ b/wavetone/agent-harness/WAVETONE.md\n@@ -0,0 +1,60 @@\n+# WaveTone Harness SOP\n+\n+## Target Software\n+\n+WaveTone 2.61 is a Windows freeware application for transcription support. It\n+opens audio files, analyzes spectrograms and fundamental frequency, detects keys\n+and chords, edits notes, and exports MIDI, text, and processed WAVE output from\n+GUI menu actions.\n+\n+The local application layout inspected for this harness:\n+\n+- `wavetone.exe`: main GUI application.\n+- `data/asdecoder.exe` plus BASS DLLs: bundled decoder support files.\n+- `wthelp/*.html`: Shift-JIS help files documenting audio analysis and export.\n+- No documented console help, batch mode, scripting API, or headless export\n+ command was found.\n+\n+## Backend Strategy\n+\n+This harness does not reimplement WaveTone analysis. The real backend remains\n+`wavetone.exe`, and `cli-anything-wavetone wavetone launch` starts that binary\n+with an optional audio file argument.\n+\n+Because WaveTone 2.61 exposes analysis settings, MIDI/text export, and WAVE\n+export through modal GUI flows, this harness provides an agent-facing project\n+manifest rather than pretending to generate native WFD data. The JSON manifest\n+tracks the source audio, intended analysis settings, labels, tempo metadata,\n+and any WFD path saved later from WaveTone itself.\n+\n+## Command Groups\n+\n+- `project`: create and edit the JSON manifest.\n+- `audio`: inspect source audio metadata before opening it in WaveTone.\n+- `wavetone`: check and launch the real WaveTone executable.\n+- `session`: keep lightweight event logs for agent workflows.\n+- `defaults`: show the default analysis settings used for new manifests.\n+\n+## Required Dependency\n+\n+WaveTone is a hard runtime dependency. Set one of:\n+\n+- `WAVETONE_EXE=C:\\path\\to\\wavetone.exe`\n+- `WAVETONE_HOME=C:\\path\\to\\wavetone2.6.1`\n+\n+The backend finder also checks common portable extraction locations such as\n+`%USERPROFILE%\\Desktop\\wavetone2.6.1\\wavetone.exe`.\n+\n+## Known Limits\n+\n+- WFD is not generated by this harness because the format is not documented.\n+- Real analysis and export still occur in the WaveTone GUI.\n+- Headless export evidence is therefore limited to launch smoke coverage and\n+ audio/project file verification until a stable automation or scripting\n+ interface is discovered.\n+\n+## Validation Notes\n+\n+The tests include unit coverage for manifests and audio probing, CLI subprocess\n+coverage, and a real-backend smoke test that launches `wavetone.exe` with a WAV\n+file and terminates it after a short wait.\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/README.md b/wavetone/agent-harness/cli_anything/wavetone/README.md\nnew file mode 100644\nindex 000000000..69f6d2593\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/README.md\n@@ -0,0 +1,60 @@\n+# cli-anything-wavetone\n+\n+Agent-native CLI harness for WaveTone 2.61 on Windows.\n+\n+WaveTone is a transcription support tool for audio files. It analyzes\n+spectrograms and fundamental frequency, supports key and chord detection, note\n+editing, and GUI-driven MIDI/text/WAVE export. This harness creates a structured\n+project manifest, probes audio files, records labels and tempo metadata, and\n+launches the real WaveTone executable.\n+\n+## Install\n+\n+```bash\n+cd wavetone/agent-harness\n+pip install -e .\n+```\n+\n+Set the backend path if WaveTone is not on the default portable path:\n+\n+```powershell\n+$env:WAVETONE_HOME = \"C:\\Users\\you\\Desktop\\wavetone2.6.1\"\n+# or\n+$env:WAVETONE_EXE = \"C:\\Users\\you\\Desktop\\wavetone2.6.1\\wavetone.exe\"\n+```\n+\n+## Usage\n+\n+```bash\n+cli-anything-wavetone --json wavetone doctor\n+cli-anything-wavetone --json project new song.wav -o song.wt.json\n+cli-anything-wavetone --project song.wt.json --json audio probe\n+cli-anything-wavetone --project song.wt.json --json project set-tempo --bpm 128\n+cli-anything-wavetone --project song.wt.json --json project add-label verse --time 32.5\n+cli-anything-wavetone --project song.wt.json --json wavetone launch\n+```\n+\n+Running `cli-anything-wavetone` with no subcommand opens the REPL.\n+\n+## Backend Truthfulness\n+\n+This harness calls the actual `wavetone.exe`. It does not reimplement\n+WaveTone's analysis, transcription, or export engine. WaveTone 2.61 does not\n+document a headless scripting interface, so analysis and export remain GUI menu\n+flows. The JSON project is an agent-facing control and planning layer around the\n+real application.\n+\n+## Tests\n+\n+```bash\n+cd wavetone/agent-harness\n+python -m pytest cli_anything/wavetone/tests/ -v\n+```\n+\n+The default test run skips real WaveTone backend tests so CI and contributors\n+without WaveTone can still run the CLI-only suite. To opt into the real Windows\n+smoke, set `CLI_ANYTHING_WAVETONE_REAL_BACKEND=1` plus `WAVETONE_EXE` or\n+`WAVETONE_HOME` pointing at a WaveTone 2.61 extraction with `wavetone.exe` and\n+the bundled `data` directory. E2E subprocess tests run the in-tree\n+`python -m cli_anything.wavetone.wavetone_cli` module by default and do not\n+silently prefer an installed `cli-anything-wavetone` from `PATH`.\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/__init__.py b/wavetone/agent-harness/cli_anything/wavetone/__init__.py\nnew file mode 100644\nindex 000000000..4400b4980\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/__init__.py\n@@ -0,0 +1,3 @@\n+\"\"\"WaveTone CLI-Anything harness.\"\"\"\n+\n+__version__ = \"1.0.0\"\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/__main__.py b/wavetone/agent-harness/cli_anything/wavetone/__main__.py\nnew file mode 100644\nindex 000000000..0c84960b3\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/__main__.py\n@@ -0,0 +1,7 @@\n+\"\"\"Run cli-anything-wavetone as a module.\"\"\"\n+\n+from .wavetone_cli import main\n+\n+\n+if __name__ == \"__main__\":\n+ main()\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/core/__init__.py b/wavetone/agent-harness/cli_anything/wavetone/core/__init__.py\nnew file mode 100644\nindex 000000000..4bb5f2a41\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/__init__.py\n@@ -0,0 +1,1 @@\n+\"\"\"Core modules for cli-anything-wavetone.\"\"\"\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\nnew file mode 100644\nindex 000000000..f35f343f5\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\n@@ -0,0 +1,112 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _safe_float(value: Any) -> float | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return float(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _safe_int(value: Any) -> int | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return int(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = _safe_float(fmt.get(\"duration\"))\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6) if duration is not None else None,\n+ \"sample_rate\": _safe_int(audio_stream.get(\"sample_rate\")),\n+ \"channels\": _safe_int(audio_stream.get(\"channels\")),\n+ \"bit_rate\": _safe_int(fmt.get(\"bit_rate\")),\n+ \"size_bytes\": _safe_int(fmt.get(\"size\")) or path.stat().st_size,\n+ \"probe_method\": \"ffprobe\",\n+ }\n+\n+\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\n+ path = normalize_audio_path(audio_path)\n+ if path.suffix.lower() in {\".wav\", \".wave\"}:\n+ try:\n+ return _probe_wav_stdlib(path)\n+ except (wave.Error, EOFError):\n+ pass\n+ try:\n+ return _probe_ffprobe(path)\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\n+ return {\n+ \"path\": str(path),\n+ \"format\": path.suffix.lower().lstrip(\".\") or None,\n+ \"codec\": None,\n+ \"duration_seconds\": None,\n+ \"sample_rate\": None,\n+ \"channels\": None,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"stat\",\n+ \"warning\": \"Install ffprobe for detailed metadata on this format.\",\n+ }\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/core/project.py b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\nnew file mode 100644\nindex 000000000..7e06d8e07\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\n@@ -0,0 +1,187 @@\n+\"\"\"Project manifest helpers for the WaveTone harness.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from copy import deepcopy\n+from datetime import datetime, timezone\n+from pathlib import Path\n+from typing import Any\n+\n+\n+SCHEMA_VERSION = \"wavetone-project/v1\"\n+SOFTWARE_VERSION = \"2.61\"\n+SUPPORTED_AUDIO_EXTENSIONS = {\n+ \".wav\",\n+ \".wave\",\n+ \".aif\",\n+ \".aiff\",\n+ \".mp3\",\n+ \".wma\",\n+ \".aac\",\n+ \".ogg\",\n+ \".oga\",\n+ \".flac\",\n+ \".wv\",\n+ \".ape\",\n+ \".alac\",\n+ \".tta\",\n+}\n+\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\n+ \"blocks_per_second\": 12,\n+ \"blocks_per_semitone\": 5,\n+ \"note_range\": \"C1-B7\",\n+ \"reference_frequency_hz\": 440.0,\n+ \"analyze_fundamental_frequency\": True,\n+ \"channel\": \"Stereo\",\n+ \"skip_analysis_dialog\": False,\n+}\n+\n+\n+def now_iso() -> str:\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\n+\n+\n+def normalize_audio_path(audio_path: str | Path) -> Path:\n+ path = Path(audio_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Audio file not found: {path}\")\n+ if not path.is_file():\n+ raise ValueError(f\"Audio path is not a file: {path}\")\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\n+ supported = \", \".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\n+ raise ValueError(f\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\")\n+ return path\n+\n+\n+def _finite_float(value: float, field_name: str) -> float:\n+ number = float(value)\n+ if not math.isfinite(number):\n+ raise ValueError(f\"{field_name} must be finite\")\n+ return number\n+\n+\n+def create_project(\n+ audio_path: str | Path,\n+ name: str | None = None,\n+ analysis_settings: dict[str, Any] | None = None,\n+) -> dict[str, Any]:\n+ audio = normalize_audio_path(audio_path)\n+ created_at = now_iso()\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\n+ if analysis_settings:\n+ settings.update(analysis_settings)\n+\n+ return {\n+ \"schema_version\": SCHEMA_VERSION,\n+ \"software\": {\"name\": \"WaveTone\", \"version\": SOFTWARE_VERSION, \"backend\": \"wavetone.exe\"},\n+ \"project\": {\"name\": name or audio.stem, \"created_at\": created_at, \"modified_at\": created_at},\n+ \"audio\": {\n+ \"path\": str(audio),\n+ \"filename\": audio.name,\n+ \"extension\": audio.suffix.lower(),\n+ \"size_bytes\": audio.stat().st_size,\n+ },\n+ \"analysis\": settings,\n+ \"tempo\": {\"bpm\": None, \"first_bar_time_seconds\": 0.0, \"meter\": \"4/4\"},\n+ \"labels\": [],\n+ \"notes\": [],\n+ \"wfd_path\": None,\n+ \"limitations\": [\n+ \"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\",\n+ \"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\",\n+ ],\n+ }\n+\n+\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\n+ project.setdefault(\"project\", {})[\"modified_at\"] = now_iso()\n+ return project\n+\n+\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\n+ path = Path(output_path).expanduser().resolve()\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ touch(project)\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return path\n+\n+\n+def load_project(project_path: str | Path) -> dict[str, Any]:\n+ path = Path(project_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Project file not found: {path}\")\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Project file must be a JSON object\")\n+ if data.get(\"schema_version\") != SCHEMA_VERSION:\n+ raise ValueError(f\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\")\n+ return data\n+\n+\n+def add_label(\n+ project: dict[str, Any],\n+ name: str,\n+ time_seconds: float,\n+ note: str | None = None,\n+) -> dict[str, Any]:\n+ time_value = _finite_float(time_seconds, \"Label time\")\n+ if time_value < 0:\n+ raise ValueError(\"Label time must be >= 0\")\n+ label: dict[str, Any] = {\"name\": name, \"time_seconds\": round(time_value, 6)}\n+ if note:\n+ label[\"note\"] = note\n+ project.setdefault(\"labels\", []).append(label)\n+ project[\"labels\"].sort(key=lambda item: item[\"time_seconds\"])\n+ return touch(project)\n+\n+\n+def set_tempo(\n+ project: dict[str, Any],\n+ bpm: float,\n+ first_bar_time_seconds: float = 0.0,\n+ meter: str = \"4/4\",\n+) -> dict[str, Any]:\n+ bpm_value = _finite_float(bpm, \"BPM\")\n+ first_bar_value = _finite_float(first_bar_time_seconds, \"First bar time\")\n+ if bpm_value <= 0:\n+ raise ValueError(\"BPM must be > 0\")\n+ if first_bar_value < 0:\n+ raise ValueError(\"First bar time must be >= 0\")\n+ project[\"tempo\"] = {\n+ \"bpm\": round(bpm_value, 6),\n+ \"first_bar_time_seconds\": round(first_bar_value, 6),\n+ \"meter\": meter,\n+ }\n+ return touch(project)\n+\n+\n+def update_analysis(project: dict[str, Any], **settings: Any) -> dict[str, Any]:\n+ analysis = project.setdefault(\"analysis\", deepcopy(DEFAULT_ANALYSIS_SETTINGS))\n+ for key, value in settings.items():\n+ if value is not None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{key} must be finite\")\n+ analysis[key] = value\n+ return touch(project)\n+\n+\n+def set_wfd_path(project: dict[str, Any], wfd_path: str | Path | None) -> dict[str, Any]:\n+ project[\"wfd_path\"] = None if wfd_path is None else str(Path(wfd_path).expanduser().resolve())\n+ return touch(project)\n+\n+\n+def project_summary(project: dict[str, Any]) -> dict[str, Any]:\n+ return {\n+ \"schema_version\": project.get(\"schema_version\"),\n+ \"name\": project.get(\"project\", {}).get(\"name\"),\n+ \"audio\": project.get(\"audio\"),\n+ \"tempo\": project.get(\"tempo\"),\n+ \"label_count\": len(project.get(\"labels\", [])),\n+ \"labels\": project.get(\"labels\", []),\n+ \"analysis\": project.get(\"analysis\"),\n+ \"wfd_path\": project.get(\"wfd_path\"),\n+ \"limitations\": project.get(\"limitations\", []),\n+ }\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/core/session.py b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\nnew file mode 100644\nindex 000000000..d9f2c7f26\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\n@@ -0,0 +1,61 @@\n+\"\"\"Small session event log for WaveTone CLI runs.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import now_iso\n+\n+\n+def _new_session() -> dict[str, Any]:\n+ return {\"schema_version\": \"wavetone-session/v1\", \"events\": []}\n+\n+\n+def _assert_json_safe(value: Any, path: str = \"payload\") -> None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{path} must contain only finite numbers\")\n+ if isinstance(value, dict):\n+ for key, item in value.items():\n+ _assert_json_safe(item, f\"{path}.{key}\")\n+ elif isinstance(value, list):\n+ for idx, item in enumerate(value):\n+ _assert_json_safe(item, f\"{path}[{idx}]\")\n+\n+\n+def _load_session_data(path: Path) -> dict[str, Any]:\n+ if not path.exists():\n+ return _new_session()\n+\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Session file must be a JSON object\")\n+\n+ events = data.get(\"events\")\n+ if events is None:\n+ data[\"events\"] = []\n+ elif not isinstance(events, list):\n+ raise ValueError(\"Session file field 'events' must be a list\")\n+\n+ return data\n+\n+\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\n+ path = Path(session_path).expanduser().resolve()\n+ data = _load_session_data(path)\n+ _assert_json_safe(payload)\n+ record = {\"time\": now_iso(), \"event\": event, \"payload\": payload}\n+ data[\"events\"].append(record)\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return record\n+\n+\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\n+ path = Path(session_path).expanduser().resolve()\n+ if not path.exists():\n+ return []\n+ data = _load_session_data(path)\n+ return list(data[\"events\"])\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/skills/SKILL.md b/wavetone/agent-harness/cli_anything/wavetone/skills/SKILL.md\nnew file mode 100644\nindex 000000000..a565109ed\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/skills/SKILL.md\n@@ -0,0 +1,53 @@\n+---\n+name: \"cli-anything-wavetone\"\n+description: \"Control WaveTone 2.61 workflows through a JSON manifest and launch the real Windows WaveTone executable.\"\n+---\n+\n+# cli-anything-wavetone\n+\n+Use this skill when an agent needs to prepare, inspect, and launch WaveTone 2.61\n+audio transcription workflows.\n+\n+## Requirements\n+\n+- Windows host.\n+- WaveTone 2.61 extracted locally.\n+- Set `WAVETONE_EXE` to `wavetone.exe` or `WAVETONE_HOME` to the extracted\n+ WaveTone directory when the default portable path is not used.\n+\n+## Core Commands\n+\n+All commands support the top-level `--json` flag.\n+\n+```bash\n+cli-anything-wavetone --json wavetone doctor\n+cli-anything-wavetone --json project new input.wav -o project.wt.json\n+cli-anything-wavetone --project project.wt.json --json audio probe\n+cli-anything-wavetone --project project.wt.json --json project set-tempo --bpm 120 --meter 4/4\n+cli-anything-wavetone --project project.wt.json --json project add-label chorus --time 64.0\n+cli-anything-wavetone --project project.wt.json --json wavetone launch\n+```\n+\n+## Command Groups\n+\n+- `project`: create manifests, set tempo, add labels, update intended analysis\n+ settings, and attach a WFD saved from WaveTone.\n+- `audio`: probe audio metadata before opening it in WaveTone.\n+- `wavetone`: run `doctor`, list supported formats, or launch the real GUI.\n+- `session`: record lightweight event logs for multi-step agent workflows.\n+- `defaults`: show default analysis settings.\n+\n+## Agent Guidance\n+\n+The JSON project manifest is not a WaveTone WFD file. It is an agent-facing plan\n+for the source audio, intended analysis settings, labels, and tempo metadata.\n+Use WaveTone itself to perform analysis and save WFD/MIDI/text/WAVE outputs.\n+\n+When running in automated checks, use:\n+\n+```bash\n+cli-anything-wavetone --json wavetone launch input.wav --wait 1 --terminate\n+```\n+\n+This confirms that the real backend can be started without leaving a persistent\n+GUI process behind.\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/__init__.py b/wavetone/agent-harness/cli_anything/wavetone/utils/__init__.py\nnew file mode 100644\nindex 000000000..4e1504df1\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/__init__.py\n@@ -0,0 +1,1 @@\n+\"\"\"Utility modules for cli-anything-wavetone.\"\"\"\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\nnew file mode 100644\nindex 000000000..3296206c8\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\n@@ -0,0 +1,568 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ display_overrides = {\"wavetone\": \"WaveTone\"}\n+ self.display_name = display_overrides.get(self.software, software.replace(\"_\", \" \").title())\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ if self.skill_path:\n+ meta_lines.extend(_meta_lines(\"Local skill:\", _display_home_path(self.skill_path)))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = f\" {sep.join(sep_parts)}\"\n+ print(sep_line)\n+\n+ # Rows\n+ for row in rows:\n+ cells = []\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\n+ row_sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ print(f\" {row_sep.join(cells)}\")\n+\n+ # ── Help display ──────────────────────────────────────────────────\n+\n+ def help(self, commands: dict[str, str]):\n+ \"\"\"Print a formatted help listing.\n+\n+ Args:\n+ commands: Dict of command -> description pairs.\n+ \"\"\"\n+ self.section(\"Commands\")\n+ max_cmd = max(len(c) for c in commands) if commands else 0\n+ for cmd, desc in commands.items():\n+ cmd_styled = self._c(self.accent, f\" {cmd:<{max_cmd}}\")\n+ desc_styled = self._c(_GRAY, f\" {desc}\")\n+ print(f\"{cmd_styled}{desc_styled}\")\n+ print()\n+\n+ # ── Goodbye ───────────────────────────────────────────────────────\n+\n+ def print_goodbye(self):\n+ \"\"\"Print a styled goodbye message.\"\"\"\n+ print(f\"\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\n\")\n+\n+ # ── Prompt toolkit session factory ────────────────────────────────\n+\n+ def create_prompt_session(self):\n+ \"\"\"Create a prompt_toolkit PromptSession with skin styling.\n+\n+ Returns:\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\n+ \"\"\"\n+ try:\n+ from prompt_toolkit import PromptSession\n+ from prompt_toolkit.history import FileHistory\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\n+\n+ style = self.get_prompt_style()\n+\n+ session = PromptSession(\n+ history=FileHistory(self.history_file),\n+ auto_suggest=AutoSuggestFromHistory(),\n+ style=style,\n+ enable_history_search=True,\n+ )\n+ return session\n+ except ImportError:\n+ return None\n+\n+ def get_input(self, pt_session, project_name: str = \"\",\n+ modified: bool = False, context: str = \"\") -> str:\n+ \"\"\"Get input from user using prompt_toolkit or fallback.\n+\n+ Args:\n+ pt_session: A prompt_toolkit PromptSession (or None).\n+ project_name: Current project name.\n+ modified: Whether project has unsaved changes.\n+ context: Optional context string.\n+\n+ Returns:\n+ User input string (stripped).\n+ \"\"\"\n+ if pt_session is not None:\n+ from prompt_toolkit.formatted_text import FormattedText\n+ tokens = self.prompt_tokens(project_name, modified, context)\n+ return pt_session.prompt(FormattedText(tokens)).strip()\n+ else:\n+ raw_prompt = self.prompt(project_name, modified, context)\n+ return input(raw_prompt).strip()\n+\n+ # ── Toolbar builder ───────────────────────────────────────────────\n+\n+ def bottom_toolbar(self, items: dict[str, str]):\n+ \"\"\"Create a bottom toolbar callback for prompt_toolkit.\n+\n+ Args:\n+ items: Dict of label -> value pairs to show in toolbar.\n+\n+ Returns:\n+ A callable that returns FormattedText for the toolbar.\n+ \"\"\"\n+ def toolbar():\n+ from prompt_toolkit.formatted_text import FormattedText\n+ parts = []\n+ for i, (k, v) in enumerate(items.items()):\n+ if i > 0:\n+ parts.append((\"class:bottom-toolbar.text\", \" │ \"))\n+ parts.append((\"class:bottom-toolbar.text\", f\" {k}: \"))\n+ parts.append((\"class:bottom-toolbar\", v))\n+ return FormattedText(parts)\n+ return toolbar\n+\n+\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\n+\n+_ANSI_256_TO_HEX = {\n+ \"\\033[38;5;33m\": \"#0087ff\", # audacity navy blue\n+ \"\\033[38;5;35m\": \"#00af5f\", # shotcut teal\n+ \"\\033[38;5;39m\": \"#00afff\", # inkscape bright blue\n+ \"\\033[38;5;40m\": \"#00d700\", # libreoffice green\n+ \"\\033[38;5;55m\": \"#5f00af\", # obs purple\n+ \"\\033[38;5;69m\": \"#5f87ff\", # kdenlive slate blue\n+ \"\\033[38;5;75m\": \"#5fafff\", # default sky blue\n+ \"\\033[38;5;80m\": \"#5fd7d7\", # brand cyan\n+ \"\\033[38;5;208m\": \"#ff8700\", # blender deep orange\n+ \"\\033[38;5;214m\": \"#ffaf00\", # gimp warm orange\n+}\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\nnew file mode 100644\nindex 000000000..81d3d35ec\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\n@@ -0,0 +1,163 @@\n+\"\"\"Backend wrapper for the real WaveTone 2.61 executable.\"\"\"\n+\n+from __future__ import annotations\n+\n+import os\n+import platform\n+import subprocess\n+import time\n+from pathlib import Path\n+from typing import Any\n+\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\n+\n+\n+REQUIRED_DATA_FILES = [\n+ \"awlib.dll\",\n+ \"bass.dll\",\n+ \"bassflac.dll\",\n+ \"basswma.dll\",\n+ \"basswv.dll\",\n+ \"bass_aac.dll\",\n+ \"bass_alac.dll\",\n+ \"bass_ape.dll\",\n+ \"bass_tta.dll\",\n+ \"asdecoder.exe\",\n+]\n+\n+\n+def default_candidates() -> list[Path]:\n+ candidates: list[Path] = []\n+ env_exe = os.environ.get(\"WAVETONE_EXE\")\n+ if env_exe:\n+ candidates.append(Path(env_exe))\n+ env_home = os.environ.get(\"WAVETONE_HOME\")\n+ if env_home:\n+ candidates.append(Path(env_home) / \"wavetone.exe\")\n+ candidates.append(Path(env_home) / \"WaveTone.exe\")\n+ home = Path.home()\n+ candidates.extend(\n+ [\n+ home / \"Desktop\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ home / \"Downloads\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ Path(\"C:/Program Files/WaveTone/wavetone.exe\"),\n+ Path(\"C:/Program Files (x86)/WaveTone/wavetone.exe\"),\n+ ]\n+ )\n+ return candidates\n+\n+\n+def find_wavetone(executable: str | Path | None = None) -> Path:\n+ candidates = [Path(executable)] if executable else default_candidates()\n+ checked: list[str] = []\n+ for candidate in candidates:\n+ path = candidate.expanduser()\n+ checked.append(str(path))\n+ if path.exists() and path.is_file():\n+ return path.resolve()\n+ raise FileNotFoundError(\n+ \"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \"\n+ \"WAVETONE_HOME to the extracted WaveTone directory. Checked: \"\n+ + \"; \".join(checked)\n+ )\n+\n+\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\n+ checks: list[dict[str, Any]] = []\n+ try:\n+ exe = find_wavetone(executable)\n+ root = exe.parent\n+ checks.append({\"name\": \"wavetone executable\", \"ok\": True, \"path\": str(exe)})\n+ except FileNotFoundError as exc:\n+ return {\n+ \"ready\": False,\n+ \"platform\": platform.system(),\n+ \"checks\": [{\"name\": \"wavetone executable\", \"ok\": False, \"error\": str(exc)}],\n+ }\n+\n+ data_dir = root / \"data\"\n+ checks.append({\"name\": \"data directory\", \"ok\": data_dir.is_dir(), \"path\": str(data_dir)})\n+ for filename in REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ checks.append({\"name\": f\"data/{filename}\", \"ok\": path.is_file(), \"path\": str(path)})\n+ help_dir = root / \"wthelp\"\n+ checks.append({\"name\": \"help directory\", \"ok\": help_dir.is_dir(), \"path\": str(help_dir)})\n+ checks.append(\n+ {\n+ \"name\": \"windows host\",\n+ \"ok\": platform.system().lower() == \"windows\",\n+ \"platform\": platform.platform(),\n+ }\n+ )\n+ return {\n+ \"ready\": all(check[\"ok\"] for check in checks),\n+ \"platform\": platform.system(),\n+ \"root\": str(root),\n+ \"checks\": checks,\n+ }\n+\n+\n+def launch_wavetone(\n+ audio_path: str | Path | None = None,\n+ executable: str | Path | None = None,\n+ wait_seconds: float = 0.0,\n+ terminate: bool = False,\n+) -> dict[str, Any]:\n+ if platform.system().lower() != \"windows\":\n+ raise RuntimeError(\"WaveTone launch requires Windows\")\n+\n+ exe = find_wavetone(executable)\n+ args = [str(exe)]\n+ audio: Path | None = None\n+ if audio_path:\n+ audio = normalize_audio_path(audio_path)\n+ args.append(str(audio))\n+\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\n+ if wait_seconds > 0:\n+ time.sleep(wait_seconds)\n+ polled = process.poll()\n+ running_after_wait = polled is None\n+ exit_code = polled\n+ terminated = False\n+ if terminate and running_after_wait:\n+ process.terminate()\n+ try:\n+ process.wait(timeout=3)\n+ except subprocess.TimeoutExpired:\n+ process.kill()\n+ process.wait(timeout=3)\n+ terminated = True\n+ exit_code = process.returncode\n+\n+ return {\n+ \"backend\": \"wavetone.exe\",\n+ \"executable\": str(exe),\n+ \"cwd\": str(exe.parent),\n+ \"pid\": process.pid,\n+ \"args\": args,\n+ \"audio_path\": str(audio) if audio else None,\n+ \"running_after_wait\": running_after_wait,\n+ \"terminated\": terminated,\n+ \"exit_code\": exit_code,\n+ \"note\": \"WaveTone analysis and export dialogs are GUI driven in version 2.61.\",\n+ }\n+\n+\n+def supported_formats() -> dict[str, Any]:\n+ return {\n+ \"extensions\": sorted(SUPPORTED_AUDIO_EXTENSIONS),\n+ \"from_readme\": [\n+ \"WAVE\",\n+ \"AIFF\",\n+ \"MP3\",\n+ \"WMA\",\n+ \"AAC\",\n+ \"Vorbis\",\n+ \"FLAC\",\n+ \"WavPack\",\n+ \"Monkey's Audio\",\n+ \"ALAC\",\n+ \"TTA\",\n+ ],\n+ }\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\ndiff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\nnew file mode 100644\nindex 000000000..4821f34d0\n--- /dev/null\n+++ b/wavetone/agent-harness/setup.py\n@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ packages=find_namespace_packages(\n+ include=[\"cli_anything.*\"],\n+ exclude=[\"cli_anything.*.tests\", \"cli_anything.*.tests.*\"],\n+ ),\n+ classifiers=[\n+ \"Development Status :: 4 - Beta\",\n+ \"Intended Audience :: Developers\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Analysis\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Editors\",\n+ \"License :: OSI Approved :: MIT License\",\n+ \"Programming Language :: Python :: 3\",\n+ \"Programming Language :: Python :: 3.10\",\n+ \"Programming Language :: Python :: 3.11\",\n+ \"Programming Language :: Python :: 3.12\",\n+ \"Operating System :: Microsoft :: Windows\",\n+ ],\n+ python_requires=\">=3.10\",\n+ install_requires=[\"click>=8.0.0\", \"prompt-toolkit>=3.0.0\"],\n+ extras_require={\"dev\": [\"pytest>=7.0.0\"]},\n+ entry_points={\n+ \"console_scripts\": [\n+ \"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\",\n+ ],\n+ },\n+ package_data={\"cli_anything.wavetone\": [\"README.md\", \"skills/SKILL.md\", \"skills/*.md\"]},\n+ include_package_data=True,\n+ zip_safe=False,\n+)\n"},"changed_files":{"kind":"list like","value":[".gitignore","README.md","README_CN.md","registry.json","skills/cli-anything-wavetone/SKILL.md","wavetone/agent-harness/WAVETONE.md","wavetone/agent-harness/cli_anything/wavetone/README.md","wavetone/agent-harness/cli_anything/wavetone/__init__.py","wavetone/agent-harness/cli_anything/wavetone/__main__.py","wavetone/agent-harness/cli_anything/wavetone/core/__init__.py","wavetone/agent-harness/cli_anything/wavetone/core/audio.py","wavetone/agent-harness/cli_anything/wavetone/core/project.py","wavetone/agent-harness/cli_anything/wavetone/core/session.py","wavetone/agent-harness/cli_anything/wavetone/skills/SKILL.md","wavetone/agent-harness/cli_anything/wavetone/tests/TEST.md","wavetone/agent-harness/cli_anything/wavetone/tests/__init__.py","wavetone/agent-harness/cli_anything/wavetone/tests/helpers.py","wavetone/agent-harness/cli_anything/wavetone/tests/test_core.py","wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py","wavetone/agent-harness/cli_anything/wavetone/utils/__init__.py","wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py","wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py","wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","wavetone/agent-harness/setup.py"],"string":"[\n \".gitignore\",\n \"README.md\",\n \"README_CN.md\",\n \"registry.json\",\n \"skills/cli-anything-wavetone/SKILL.md\",\n \"wavetone/agent-harness/WAVETONE.md\",\n \"wavetone/agent-harness/cli_anything/wavetone/README.md\",\n \"wavetone/agent-harness/cli_anything/wavetone/__init__.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/__main__.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/core/__init__.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/core/audio.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/core/project.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/core/session.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/skills/SKILL.md\",\n \"wavetone/agent-harness/cli_anything/wavetone/tests/TEST.md\",\n \"wavetone/agent-harness/cli_anything/wavetone/tests/__init__.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/tests/helpers.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/tests/test_core.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/utils/__init__.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\",\n \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"wavetone/agent-harness/setup.py\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"The “real backend” tests are unconditional and will fail on non-Windows hosts or in CI environments where WaveTone isn’t installed/configured (e.g., `doctor` asserts `ready is True`). Consider marking `TestRealWaveToneBackend` (or its tests) with `pytest.mark.skipif` based on platform and/or presence of `WAVETONE_EXE`/`WAVETONE_HOME`, or put them behind an opt-in marker (e.g., `-m real_backend`) so default test runs remain reliable.","path":"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py","hunk":"@@ -0,0 +1,118 @@\n+from __future__ import annotations\n+\n+import json\n+import math\n+import os\n+import shutil\n+import struct\n+import subprocess\n+import sys\n+import wave\n+from pathlib import Path\n+\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+\n+def make_wav(path: Path, freq: float = 440.0, duration: float = 0.5, sample_rate: int = 8000) -> Path:\n+ frames = int(duration * sample_rate)\n+ with wave.open(str(path), \"wb\") as handle:\n+ handle.setnchannels(1)\n+ handle.setsampwidth(2)\n+ handle.setframerate(sample_rate)\n+ for idx in range(frames):\n+ sample = int(16000 * math.sin(2 * math.pi * freq * idx / sample_rate))\n+ handle.writeframes(struct.pack(\"<h\", sample))\n+ return path\n+\n+\n+def _resolve_cli(name: str) -> list[str]:\n+ \"\"\"Resolve installed CLI command; fall back to python -m for development.\"\"\"\n+ force = os.environ.get(\"CLI_ANYTHING_FORCE_INSTALLED\", \"\").strip() == \"1\"\n+ path = shutil.which(name)\n+ if path:\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+ if force:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ print(f\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+\n+class TestCLISubprocess:\n+ CLI_BASE = _resolve_cli(\"cli-anything-wavetone\")\n+\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+class TestRealWaveToneBackend:\n+ CLI_BASE = _resolve_cli(\"cli-anything-wavetone\")\n+\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"ready\"] is True","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2ceb45661\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\n@@ -0,0 +1,153 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\n+ \"\"\"Run the in-tree module by default; installed entry points are opt-in.\"\"\"\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ if not force_installed:\n+ print(f\"[_resolve_cli] Using source module: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+ path = shutil.which(name)\n+ if not path:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+\n+\n+def _env_flag_enabled(name: str) -> bool:\n+ return os.environ.get(name, \"\").strip().lower() in {\"1\", \"true\", \"yes\", \"on\"}\n+\n+\n+def _real_backend_ready() -> tuple[bool, str]:\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\n+ return False, f\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+ if sys.platform != \"win32\":\n+ return False, \"WaveTone real-backend tests require Windows\"\n+ if not (os.environ.get(\"WAVETONE_EXE\") or os.environ.get(\"WAVETONE_HOME\")):\n+ return False, \"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+\n+ status = wavetone_backend.doctor()\n+ if status.get(\"ready\"):\n+ return True, \"\"\n+\n+ failed_checks = [check[\"name\"] for check in status.get(\"checks\", []) if not check.get(\"ok\")]\n+ reason = \", \".join(failed_checks) if failed_checks else \"WaveTone backend is not ready\"\n+ return False, f\"WaveTone real backend unavailable: {reason}\"\n+\n+\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\n+\n+\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\n+ monkeypatch.delenv(\"WAVETONE_EXE\", raising=False)\n+ monkeypatch.delenv(\"WAVETONE_HOME\", raising=False)\n+\n+ ready, reason = _real_backend_ready()\n+\n+ assert ready is False\n+ assert REAL_BACKEND_ENV in reason\n+\n+\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setenv(\"CLI_ANYTHING_FORCE_INSTALLED\", \"1\")\n+ monkeypatch.setattr(shutil, \"which\", lambda name: pytest.fail(\"default resolver should not inspect PATH\"))\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\") == [sys.executable, \"-m\", \"cli_anything.wavetone.wavetone_cli\"]\n+\n+\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setattr(shutil, \"which\", lambda name: \"C:/installed/cli-anything-wavetone.exe\")\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\", force_installed=True) == [\"C:/installed/cli-anything-wavetone.exe\"]\n+\n+\n+class TestCLISubprocess:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\n+class TestRealWaveToneBackend:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"ready\"] is True\n+ assert any(check[\"name\"] == \"data/asdecoder.exe\" and check[\"ok\"] for check in data[\"checks\"])\n+ print(f\"\\n WaveTone root: {data['root']}\")\n+\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\n+ exe = wavetone_backend.find_wavetone()\n+ wav = make_wav(tmp_path / \"launch.wav\")\n+ result = self._run(\n+ [\n+ \"--json\",\n+ \"wavetone\",\n+ \"launch\",\n+ str(wav),\n+ \"--exe\",\n+ str(exe),\n+ \"--wait\",\n+ \"1\",\n+ \"--terminate\",\n+ ]\n+ )\n+ data = json.loads(result.stdout)[\"launch\"]\n+ assert data[\"backend\"] == \"wavetone.exe\"\n+ assert data[\"audio_path\"] == str(wav.resolve())\n+ assert data[\"running_after_wait\"] is True\n+ assert data[\"terminated\"] is True\n+ print(f\"\\n Launched WaveTone PID: {data['pid']}\")\n+ print(f\" WAV: {wav} ({wav.stat().st_size:,} bytes)\")\n"},{"comment":"Catching all exceptions and printing `str(exc)` can produce unhelpful output for Click-specific control flow (e.g., `click.exceptions.Exit(1)` prints just `1`). Handle `click.ClickException` and `click.exceptions.Exit` explicitly so the REPL prints a meaningful message (and optionally continues/returns based on exit code) while still keeping a final broad catch for unexpected errors.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,339 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ ctx.obj[\"project\"] = project_path\n+ ctx.obj[\"json\"] = json_mode\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"wavetone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = shlex.split(line, posix=(os.name != \"nt\"))\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except Exception as exc: # pragma: no cover\n+ skin.error(str(exc))","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"The table separator construction is inconsistent: `sep_parts` is computed but not used, and the join string `'───'` hardcodes spacing/thickness in a way that can misalign with the header separator (`_V_LINE`). Build the separator line using the same column widths and the same delimiter logic as the header (or reuse `sep_parts`) so the rendered table consistently aligns.","path":"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py","hunk":"@@ -0,0 +1,567 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ self.display_name = software.replace(\"_\", \" \").title()\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = self._c(_DARK_GRAY, f\" {'───'.join([_H_LINE * w for w in col_widths])}\")\n+ print(sep_line)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\nnew file mode 100644\nindex 000000000..3296206c8\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\n@@ -0,0 +1,568 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ display_overrides = {\"wavetone\": \"WaveTone\"}\n+ self.display_name = display_overrides.get(self.software, software.replace(\"_\", \" \").title())\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ if self.skill_path:\n+ meta_lines.extend(_meta_lines(\"Local skill:\", _display_home_path(self.skill_path)))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = f\" {sep.join(sep_parts)}\"\n+ print(sep_line)\n+\n+ # Rows\n+ for row in rows:\n+ cells = []\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\n+ row_sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ print(f\" {row_sep.join(cells)}\")\n+\n+ # ── Help display ──────────────────────────────────────────────────\n+\n+ def help(self, commands: dict[str, str]):\n+ \"\"\"Print a formatted help listing.\n+\n+ Args:\n+ commands: Dict of command -> description pairs.\n+ \"\"\"\n+ self.section(\"Commands\")\n+ max_cmd = max(len(c) for c in commands) if commands else 0\n+ for cmd, desc in commands.items():\n+ cmd_styled = self._c(self.accent, f\" {cmd:<{max_cmd}}\")\n+ desc_styled = self._c(_GRAY, f\" {desc}\")\n+ print(f\"{cmd_styled}{desc_styled}\")\n+ print()\n+\n+ # ── Goodbye ───────────────────────────────────────────────────────\n+\n+ def print_goodbye(self):\n+ \"\"\"Print a styled goodbye message.\"\"\"\n+ print(f\"\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\n\")\n+\n+ # ── Prompt toolkit session factory ────────────────────────────────\n+\n+ def create_prompt_session(self):\n+ \"\"\"Create a prompt_toolkit PromptSession with skin styling.\n+\n+ Returns:\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\n+ \"\"\"\n+ try:\n+ from prompt_toolkit import PromptSession\n+ from prompt_toolkit.history import FileHistory\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\n+\n+ style = self.get_prompt_style()\n+\n+ session = PromptSession(\n+ history=FileHistory(self.history_file),\n+ auto_suggest=AutoSuggestFromHistory(),\n+ style=style,\n+ enable_history_search=True,\n+ )\n+ return session\n+ except ImportError:\n+ return None\n+\n+ def get_input(self, pt_session, project_name: str = \"\",\n+ modified: bool = False, context: str = \"\") -> str:\n+ \"\"\"Get input from user using prompt_toolkit or fallback.\n+\n+ Args:\n+ pt_session: A prompt_toolkit PromptSession (or None).\n+ project_name: Current project name.\n+ modified: Whether project has unsaved changes.\n+ context: Optional context string.\n+\n+ Returns:\n+ User input string (stripped).\n+ \"\"\"\n+ if pt_session is not None:\n+ from prompt_toolkit.formatted_text import FormattedText\n+ tokens = self.prompt_tokens(project_name, modified, context)\n+ return pt_session.prompt(FormattedText(tokens)).strip()\n+ else:\n+ raw_prompt = self.prompt(project_name, modified, context)\n+ return input(raw_prompt).strip()\n+\n+ # ── Toolbar builder ───────────────────────────────────────────────\n+\n+ def bottom_toolbar(self, items: dict[str, str]):\n+ \"\"\"Create a bottom toolbar callback for prompt_toolkit.\n+\n+ Args:\n+ items: Dict of label -> value pairs to show in toolbar.\n+\n+ Returns:\n+ A callable that returns FormattedText for the toolbar.\n+ \"\"\"\n+ def toolbar():\n+ from prompt_toolkit.formatted_text import FormattedText\n+ parts = []\n+ for i, (k, v) in enumerate(items.items()):\n+ if i > 0:\n+ parts.append((\"class:bottom-toolbar.text\", \" │ \"))\n+ parts.append((\"class:bottom-toolbar.text\", f\" {k}: \"))\n+ parts.append((\"class:bottom-toolbar\", v))\n+ return FormattedText(parts)\n+ return toolbar\n+\n+\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\n+\n+_ANSI_256_TO_HEX = {\n+ \"\\033[38;5;33m\": \"#0087ff\", # audacity navy blue\n+ \"\\033[38;5;35m\": \"#00af5f\", # shotcut teal\n+ \"\\033[38;5;39m\": \"#00afff\", # inkscape bright blue\n+ \"\\033[38;5;40m\": \"#00d700\", # libreoffice green\n+ \"\\033[38;5;55m\": \"#5f00af\", # obs purple\n+ \"\\033[38;5;69m\": \"#5f87ff\", # kdenlive slate blue\n+ \"\\033[38;5;75m\": \"#5fafff\", # default sky blue\n+ \"\\033[38;5;80m\": \"#5fd7d7\", # brand cyan\n+ \"\\033[38;5;208m\": \"#ff8700\", # blender deep orange\n+ \"\\033[38;5;214m\": \"#ffaf00\", # gimp warm orange\n+}\n"},{"comment":"`process.poll()` is called twice back-to-back, which can make `running_after_wait` and `exit_code` slightly inconsistent if the process exits between calls. Store the poll result once (e.g., `polled = process.poll()`) and derive both fields from it for clearer, deterministic reporting.","path":"wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py","hunk":"@@ -0,0 +1,159 @@\n+\"\"\"Backend wrapper for the real WaveTone 2.61 executable.\"\"\"\n+\n+from __future__ import annotations\n+\n+import os\n+import platform\n+import subprocess\n+import time\n+from pathlib import Path\n+from typing import Any\n+\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\n+\n+\n+REQUIRED_DATA_FILES = [\n+ \"awlib.dll\",\n+ \"bass.dll\",\n+ \"bassflac.dll\",\n+ \"basswma.dll\",\n+ \"basswv.dll\",\n+ \"bass_aac.dll\",\n+ \"bass_alac.dll\",\n+ \"bass_ape.dll\",\n+ \"bass_tta.dll\",\n+ \"asdecoder.exe\",\n+]\n+\n+\n+def default_candidates() -> list[Path]:\n+ candidates: list[Path] = []\n+ env_exe = os.environ.get(\"WAVETONE_EXE\")\n+ if env_exe:\n+ candidates.append(Path(env_exe))\n+ env_home = os.environ.get(\"WAVETONE_HOME\")\n+ if env_home:\n+ candidates.append(Path(env_home) / \"wavetone.exe\")\n+ candidates.append(Path(env_home) / \"WaveTone.exe\")\n+ home = Path.home()\n+ candidates.extend(\n+ [\n+ home / \"Desktop\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ home / \"Downloads\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ Path(\"C:/Program Files/WaveTone/wavetone.exe\"),\n+ Path(\"C:/Program Files (x86)/WaveTone/wavetone.exe\"),\n+ ]\n+ )\n+ return candidates\n+\n+\n+def find_wavetone(executable: str | Path | None = None) -> Path:\n+ candidates = [Path(executable)] if executable else default_candidates()\n+ checked: list[str] = []\n+ for candidate in candidates:\n+ path = candidate.expanduser()\n+ checked.append(str(path))\n+ if path.exists() and path.is_file():\n+ return path.resolve()\n+ raise FileNotFoundError(\n+ \"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \"\n+ \"WAVETONE_HOME to the extracted WaveTone directory. Checked: \"\n+ + \"; \".join(checked)\n+ )\n+\n+\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\n+ checks: list[dict[str, Any]] = []\n+ try:\n+ exe = find_wavetone(executable)\n+ root = exe.parent\n+ checks.append({\"name\": \"wavetone executable\", \"ok\": True, \"path\": str(exe)})\n+ except FileNotFoundError as exc:\n+ return {\n+ \"ready\": False,\n+ \"platform\": platform.system(),\n+ \"checks\": [{\"name\": \"wavetone executable\", \"ok\": False, \"error\": str(exc)}],\n+ }\n+\n+ data_dir = root / \"data\"\n+ checks.append({\"name\": \"data directory\", \"ok\": data_dir.is_dir(), \"path\": str(data_dir)})\n+ for filename in REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ checks.append({\"name\": f\"data/{filename}\", \"ok\": path.exists(), \"path\": str(path)})\n+ help_dir = root / \"wthelp\"\n+ checks.append({\"name\": \"help directory\", \"ok\": help_dir.is_dir(), \"path\": str(help_dir)})\n+ checks.append(\n+ {\n+ \"name\": \"windows host\",\n+ \"ok\": platform.system().lower() == \"windows\",\n+ \"platform\": platform.platform(),\n+ }\n+ )\n+ return {\n+ \"ready\": all(check[\"ok\"] for check in checks),\n+ \"platform\": platform.system(),\n+ \"root\": str(root),\n+ \"checks\": checks,\n+ }\n+\n+\n+def launch_wavetone(\n+ audio_path: str | Path | None = None,\n+ executable: str | Path | None = None,\n+ wait_seconds: float = 0.0,\n+ terminate: bool = False,\n+) -> dict[str, Any]:\n+ exe = find_wavetone(executable)\n+ args = [str(exe)]\n+ audio: Path | None = None\n+ if audio_path:\n+ audio = normalize_audio_path(audio_path)\n+ args.append(str(audio))\n+\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\n+ if wait_seconds > 0:\n+ time.sleep(wait_seconds)\n+ running_after_wait = process.poll() is None\n+ exit_code = process.poll()","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\nnew file mode 100644\nindex 000000000..81d3d35ec\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\n@@ -0,0 +1,163 @@\n+\"\"\"Backend wrapper for the real WaveTone 2.61 executable.\"\"\"\n+\n+from __future__ import annotations\n+\n+import os\n+import platform\n+import subprocess\n+import time\n+from pathlib import Path\n+from typing import Any\n+\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\n+\n+\n+REQUIRED_DATA_FILES = [\n+ \"awlib.dll\",\n+ \"bass.dll\",\n+ \"bassflac.dll\",\n+ \"basswma.dll\",\n+ \"basswv.dll\",\n+ \"bass_aac.dll\",\n+ \"bass_alac.dll\",\n+ \"bass_ape.dll\",\n+ \"bass_tta.dll\",\n+ \"asdecoder.exe\",\n+]\n+\n+\n+def default_candidates() -> list[Path]:\n+ candidates: list[Path] = []\n+ env_exe = os.environ.get(\"WAVETONE_EXE\")\n+ if env_exe:\n+ candidates.append(Path(env_exe))\n+ env_home = os.environ.get(\"WAVETONE_HOME\")\n+ if env_home:\n+ candidates.append(Path(env_home) / \"wavetone.exe\")\n+ candidates.append(Path(env_home) / \"WaveTone.exe\")\n+ home = Path.home()\n+ candidates.extend(\n+ [\n+ home / \"Desktop\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ home / \"Downloads\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ Path(\"C:/Program Files/WaveTone/wavetone.exe\"),\n+ Path(\"C:/Program Files (x86)/WaveTone/wavetone.exe\"),\n+ ]\n+ )\n+ return candidates\n+\n+\n+def find_wavetone(executable: str | Path | None = None) -> Path:\n+ candidates = [Path(executable)] if executable else default_candidates()\n+ checked: list[str] = []\n+ for candidate in candidates:\n+ path = candidate.expanduser()\n+ checked.append(str(path))\n+ if path.exists() and path.is_file():\n+ return path.resolve()\n+ raise FileNotFoundError(\n+ \"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \"\n+ \"WAVETONE_HOME to the extracted WaveTone directory. Checked: \"\n+ + \"; \".join(checked)\n+ )\n+\n+\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\n+ checks: list[dict[str, Any]] = []\n+ try:\n+ exe = find_wavetone(executable)\n+ root = exe.parent\n+ checks.append({\"name\": \"wavetone executable\", \"ok\": True, \"path\": str(exe)})\n+ except FileNotFoundError as exc:\n+ return {\n+ \"ready\": False,\n+ \"platform\": platform.system(),\n+ \"checks\": [{\"name\": \"wavetone executable\", \"ok\": False, \"error\": str(exc)}],\n+ }\n+\n+ data_dir = root / \"data\"\n+ checks.append({\"name\": \"data directory\", \"ok\": data_dir.is_dir(), \"path\": str(data_dir)})\n+ for filename in REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ checks.append({\"name\": f\"data/{filename}\", \"ok\": path.is_file(), \"path\": str(path)})\n+ help_dir = root / \"wthelp\"\n+ checks.append({\"name\": \"help directory\", \"ok\": help_dir.is_dir(), \"path\": str(help_dir)})\n+ checks.append(\n+ {\n+ \"name\": \"windows host\",\n+ \"ok\": platform.system().lower() == \"windows\",\n+ \"platform\": platform.platform(),\n+ }\n+ )\n+ return {\n+ \"ready\": all(check[\"ok\"] for check in checks),\n+ \"platform\": platform.system(),\n+ \"root\": str(root),\n+ \"checks\": checks,\n+ }\n+\n+\n+def launch_wavetone(\n+ audio_path: str | Path | None = None,\n+ executable: str | Path | None = None,\n+ wait_seconds: float = 0.0,\n+ terminate: bool = False,\n+) -> dict[str, Any]:\n+ if platform.system().lower() != \"windows\":\n+ raise RuntimeError(\"WaveTone launch requires Windows\")\n+\n+ exe = find_wavetone(executable)\n+ args = [str(exe)]\n+ audio: Path | None = None\n+ if audio_path:\n+ audio = normalize_audio_path(audio_path)\n+ args.append(str(audio))\n+\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\n+ if wait_seconds > 0:\n+ time.sleep(wait_seconds)\n+ polled = process.poll()\n+ running_after_wait = polled is None\n+ exit_code = polled\n+ terminated = False\n+ if terminate and running_after_wait:\n+ process.terminate()\n+ try:\n+ process.wait(timeout=3)\n+ except subprocess.TimeoutExpired:\n+ process.kill()\n+ process.wait(timeout=3)\n+ terminated = True\n+ exit_code = process.returncode\n+\n+ return {\n+ \"backend\": \"wavetone.exe\",\n+ \"executable\": str(exe),\n+ \"cwd\": str(exe.parent),\n+ \"pid\": process.pid,\n+ \"args\": args,\n+ \"audio_path\": str(audio) if audio else None,\n+ \"running_after_wait\": running_after_wait,\n+ \"terminated\": terminated,\n+ \"exit_code\": exit_code,\n+ \"note\": \"WaveTone analysis and export dialogs are GUI driven in version 2.61.\",\n+ }\n+\n+\n+def supported_formats() -> dict[str, Any]:\n+ return {\n+ \"extensions\": sorted(SUPPORTED_AUDIO_EXTENSIONS),\n+ \"from_readme\": [\n+ \"WAVE\",\n+ \"AIFF\",\n+ \"MP3\",\n+ \"WMA\",\n+ \"AAC\",\n+ \"Vorbis\",\n+ \"FLAC\",\n+ \"WavPack\",\n+ \"Monkey's Audio\",\n+ \"ALAC\",\n+ \"TTA\",\n+ ],\n+ }\n"},{"comment":"**<sub><sub></sub></sub> Skip real-backend tests when WaveTone is absent**\n\nIn environments without a Windows WaveTone 2.61 install, the default test run now fails because this test invokes `wavetone doctor` with `check=True`, and the same class also calls `find_wavetone()` directly below. I verified this by running `python -m pytest -q` from `wavetone/agent-harness` on Linux, where the suite fails with `WaveTone executable not found`; the README notes these full E2E tests require Windows and an extracted WaveTone install, so they should be gated with a skip marker/env check rather than included unconditionally in the default pytest collection.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py","hunk":"@@ -0,0 +1,118 @@\n+from __future__ import annotations\n+\n+import json\n+import math\n+import os\n+import shutil\n+import struct\n+import subprocess\n+import sys\n+import wave\n+from pathlib import Path\n+\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+\n+def make_wav(path: Path, freq: float = 440.0, duration: float = 0.5, sample_rate: int = 8000) -> Path:\n+ frames = int(duration * sample_rate)\n+ with wave.open(str(path), \"wb\") as handle:\n+ handle.setnchannels(1)\n+ handle.setsampwidth(2)\n+ handle.setframerate(sample_rate)\n+ for idx in range(frames):\n+ sample = int(16000 * math.sin(2 * math.pi * freq * idx / sample_rate))\n+ handle.writeframes(struct.pack(\"<h\", sample))\n+ return path\n+\n+\n+def _resolve_cli(name: str) -> list[str]:\n+ \"\"\"Resolve installed CLI command; fall back to python -m for development.\"\"\"\n+ force = os.environ.get(\"CLI_ANYTHING_FORCE_INSTALLED\", \"\").strip() == \"1\"\n+ path = shutil.which(name)\n+ if path:\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+ if force:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ print(f\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+\n+class TestCLISubprocess:\n+ CLI_BASE = _resolve_cli(\"cli-anything-wavetone\")\n+\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+class TestRealWaveToneBackend:\n+ CLI_BASE = _resolve_cli(\"cli-anything-wavetone\")\n+\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2ceb45661\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\n@@ -0,0 +1,153 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\n+ \"\"\"Run the in-tree module by default; installed entry points are opt-in.\"\"\"\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ if not force_installed:\n+ print(f\"[_resolve_cli] Using source module: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+ path = shutil.which(name)\n+ if not path:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+\n+\n+def _env_flag_enabled(name: str) -> bool:\n+ return os.environ.get(name, \"\").strip().lower() in {\"1\", \"true\", \"yes\", \"on\"}\n+\n+\n+def _real_backend_ready() -> tuple[bool, str]:\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\n+ return False, f\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+ if sys.platform != \"win32\":\n+ return False, \"WaveTone real-backend tests require Windows\"\n+ if not (os.environ.get(\"WAVETONE_EXE\") or os.environ.get(\"WAVETONE_HOME\")):\n+ return False, \"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+\n+ status = wavetone_backend.doctor()\n+ if status.get(\"ready\"):\n+ return True, \"\"\n+\n+ failed_checks = [check[\"name\"] for check in status.get(\"checks\", []) if not check.get(\"ok\")]\n+ reason = \", \".join(failed_checks) if failed_checks else \"WaveTone backend is not ready\"\n+ return False, f\"WaveTone real backend unavailable: {reason}\"\n+\n+\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\n+\n+\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\n+ monkeypatch.delenv(\"WAVETONE_EXE\", raising=False)\n+ monkeypatch.delenv(\"WAVETONE_HOME\", raising=False)\n+\n+ ready, reason = _real_backend_ready()\n+\n+ assert ready is False\n+ assert REAL_BACKEND_ENV in reason\n+\n+\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setenv(\"CLI_ANYTHING_FORCE_INSTALLED\", \"1\")\n+ monkeypatch.setattr(shutil, \"which\", lambda name: pytest.fail(\"default resolver should not inspect PATH\"))\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\") == [sys.executable, \"-m\", \"cli_anything.wavetone.wavetone_cli\"]\n+\n+\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setattr(shutil, \"which\", lambda name: \"C:/installed/cli-anything-wavetone.exe\")\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\", force_installed=True) == [\"C:/installed/cli-anything-wavetone.exe\"]\n+\n+\n+class TestCLISubprocess:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\n+class TestRealWaveToneBackend:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"ready\"] is True\n+ assert any(check[\"name\"] == \"data/asdecoder.exe\" and check[\"ok\"] for check in data[\"checks\"])\n+ print(f\"\\n WaveTone root: {data['root']}\")\n+\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\n+ exe = wavetone_backend.find_wavetone()\n+ wav = make_wav(tmp_path / \"launch.wav\")\n+ result = self._run(\n+ [\n+ \"--json\",\n+ \"wavetone\",\n+ \"launch\",\n+ str(wav),\n+ \"--exe\",\n+ str(exe),\n+ \"--wait\",\n+ \"1\",\n+ \"--terminate\",\n+ ]\n+ )\n+ data = json.loads(result.stdout)[\"launch\"]\n+ assert data[\"backend\"] == \"wavetone.exe\"\n+ assert data[\"audio_path\"] == str(wav.resolve())\n+ assert data[\"running_after_wait\"] is True\n+ assert data[\"terminated\"] is True\n+ print(f\"\\n Launched WaveTone PID: {data['pid']}\")\n+ print(f\" WAV: {wav} ({wav.stat().st_size:,} bytes)\")\n"},{"comment":"**<sub><sub></sub></sub> Preserve the REPL project context**\n\nWhen the REPL is started with `cli-anything-wavetone --project song.wt.json`, every command entered inside the REPL re-enters this group callback without a `--project` option, so `project_path` is `None` and this assignment overwrites the inherited `ctx.obj[\"project\"]`. Project-scoped commands like `audio probe` then fail with “Project path required” even though the REPL was launched with a project; only update the stored value when an option was explicitly provided, or pass the existing context through unchanged for nested REPL invocations.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,344 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ ctx.obj[\"project\"] = project_path\n+ ctx.obj[\"json\"] = json_mode","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"`accent_hex` is computed but never used in `prompt_tokens()`. Please either remove it or use it to drive token styling (to keep the method consistent with `get_prompt_style()`).","path":"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py","hunk":"@@ -0,0 +1,567 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ self.display_name = software.replace(\"_\", \" \").title()\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+ tokens = []","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\nnew file mode 100644\nindex 000000000..3296206c8\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\n@@ -0,0 +1,568 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ display_overrides = {\"wavetone\": \"WaveTone\"}\n+ self.display_name = display_overrides.get(self.software, software.replace(\"_\", \" \").title())\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ if self.skill_path:\n+ meta_lines.extend(_meta_lines(\"Local skill:\", _display_home_path(self.skill_path)))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = f\" {sep.join(sep_parts)}\"\n+ print(sep_line)\n+\n+ # Rows\n+ for row in rows:\n+ cells = []\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\n+ row_sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ print(f\" {row_sep.join(cells)}\")\n+\n+ # ── Help display ──────────────────────────────────────────────────\n+\n+ def help(self, commands: dict[str, str]):\n+ \"\"\"Print a formatted help listing.\n+\n+ Args:\n+ commands: Dict of command -> description pairs.\n+ \"\"\"\n+ self.section(\"Commands\")\n+ max_cmd = max(len(c) for c in commands) if commands else 0\n+ for cmd, desc in commands.items():\n+ cmd_styled = self._c(self.accent, f\" {cmd:<{max_cmd}}\")\n+ desc_styled = self._c(_GRAY, f\" {desc}\")\n+ print(f\"{cmd_styled}{desc_styled}\")\n+ print()\n+\n+ # ── Goodbye ───────────────────────────────────────────────────────\n+\n+ def print_goodbye(self):\n+ \"\"\"Print a styled goodbye message.\"\"\"\n+ print(f\"\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\n\")\n+\n+ # ── Prompt toolkit session factory ────────────────────────────────\n+\n+ def create_prompt_session(self):\n+ \"\"\"Create a prompt_toolkit PromptSession with skin styling.\n+\n+ Returns:\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\n+ \"\"\"\n+ try:\n+ from prompt_toolkit import PromptSession\n+ from prompt_toolkit.history import FileHistory\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\n+\n+ style = self.get_prompt_style()\n+\n+ session = PromptSession(\n+ history=FileHistory(self.history_file),\n+ auto_suggest=AutoSuggestFromHistory(),\n+ style=style,\n+ enable_history_search=True,\n+ )\n+ return session\n+ except ImportError:\n+ return None\n+\n+ def get_input(self, pt_session, project_name: str = \"\",\n+ modified: bool = False, context: str = \"\") -> str:\n+ \"\"\"Get input from user using prompt_toolkit or fallback.\n+\n+ Args:\n+ pt_session: A prompt_toolkit PromptSession (or None).\n+ project_name: Current project name.\n+ modified: Whether project has unsaved changes.\n+ context: Optional context string.\n+\n+ Returns:\n+ User input string (stripped).\n+ \"\"\"\n+ if pt_session is not None:\n+ from prompt_toolkit.formatted_text import FormattedText\n+ tokens = self.prompt_tokens(project_name, modified, context)\n+ return pt_session.prompt(FormattedText(tokens)).strip()\n+ else:\n+ raw_prompt = self.prompt(project_name, modified, context)\n+ return input(raw_prompt).strip()\n+\n+ # ── Toolbar builder ───────────────────────────────────────────────\n+\n+ def bottom_toolbar(self, items: dict[str, str]):\n+ \"\"\"Create a bottom toolbar callback for prompt_toolkit.\n+\n+ Args:\n+ items: Dict of label -> value pairs to show in toolbar.\n+\n+ Returns:\n+ A callable that returns FormattedText for the toolbar.\n+ \"\"\"\n+ def toolbar():\n+ from prompt_toolkit.formatted_text import FormattedText\n+ parts = []\n+ for i, (k, v) in enumerate(items.items()):\n+ if i > 0:\n+ parts.append((\"class:bottom-toolbar.text\", \" │ \"))\n+ parts.append((\"class:bottom-toolbar.text\", f\" {k}: \"))\n+ parts.append((\"class:bottom-toolbar\", v))\n+ return FormattedText(parts)\n+ return toolbar\n+\n+\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\n+\n+_ANSI_256_TO_HEX = {\n+ \"\\033[38;5;33m\": \"#0087ff\", # audacity navy blue\n+ \"\\033[38;5;35m\": \"#00af5f\", # shotcut teal\n+ \"\\033[38;5;39m\": \"#00afff\", # inkscape bright blue\n+ \"\\033[38;5;40m\": \"#00d700\", # libreoffice green\n+ \"\\033[38;5;55m\": \"#5f00af\", # obs purple\n+ \"\\033[38;5;69m\": \"#5f87ff\", # kdenlive slate blue\n+ \"\\033[38;5;75m\": \"#5fafff\", # default sky blue\n+ \"\\033[38;5;80m\": \"#5fd7d7\", # brand cyan\n+ \"\\033[38;5;208m\": \"#ff8700\", # blender deep orange\n+ \"\\033[38;5;214m\": \"#ffaf00\", # gimp warm orange\n+}\n"},{"comment":"`FormattedText` is imported in `create_prompt_session()` but not used in that function. Removing the unused import will avoid lint failures and reduce noise.","path":"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py","hunk":"@@ -0,0 +1,567 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ self.display_name = software.replace(\"_\", \" \").title()\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = f\" {sep.join(sep_parts)}\"\n+ print(sep_line)\n+\n+ # Rows\n+ for row in rows:\n+ cells = []\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\n+ row_sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ print(f\" {row_sep.join(cells)}\")\n+\n+ # ── Help display ──────────────────────────────────────────────────\n+\n+ def help(self, commands: dict[str, str]):\n+ \"\"\"Print a formatted help listing.\n+\n+ Args:\n+ commands: Dict of command -> description pairs.\n+ \"\"\"\n+ self.section(\"Commands\")\n+ max_cmd = max(len(c) for c in commands) if commands else 0\n+ for cmd, desc in commands.items():\n+ cmd_styled = self._c(self.accent, f\" {cmd:<{max_cmd}}\")\n+ desc_styled = self._c(_GRAY, f\" {desc}\")\n+ print(f\"{cmd_styled}{desc_styled}\")\n+ print()\n+\n+ # ── Goodbye ───────────────────────────────────────────────────────\n+\n+ def print_goodbye(self):\n+ \"\"\"Print a styled goodbye message.\"\"\"\n+ print(f\"\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\n\")\n+\n+ # ── Prompt toolkit session factory ────────────────────────────────\n+\n+ def create_prompt_session(self):\n+ \"\"\"Create a prompt_toolkit PromptSession with skin styling.\n+\n+ Returns:\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\n+ \"\"\"\n+ try:\n+ from prompt_toolkit import PromptSession\n+ from prompt_toolkit.history import FileHistory\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\n+ from prompt_toolkit.formatted_text import FormattedText","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\nnew file mode 100644\nindex 000000000..3296206c8\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\n@@ -0,0 +1,568 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ display_overrides = {\"wavetone\": \"WaveTone\"}\n+ self.display_name = display_overrides.get(self.software, software.replace(\"_\", \" \").title())\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ if self.skill_path:\n+ meta_lines.extend(_meta_lines(\"Local skill:\", _display_home_path(self.skill_path)))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = f\" {sep.join(sep_parts)}\"\n+ print(sep_line)\n+\n+ # Rows\n+ for row in rows:\n+ cells = []\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\n+ row_sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ print(f\" {row_sep.join(cells)}\")\n+\n+ # ── Help display ──────────────────────────────────────────────────\n+\n+ def help(self, commands: dict[str, str]):\n+ \"\"\"Print a formatted help listing.\n+\n+ Args:\n+ commands: Dict of command -> description pairs.\n+ \"\"\"\n+ self.section(\"Commands\")\n+ max_cmd = max(len(c) for c in commands) if commands else 0\n+ for cmd, desc in commands.items():\n+ cmd_styled = self._c(self.accent, f\" {cmd:<{max_cmd}}\")\n+ desc_styled = self._c(_GRAY, f\" {desc}\")\n+ print(f\"{cmd_styled}{desc_styled}\")\n+ print()\n+\n+ # ── Goodbye ───────────────────────────────────────────────────────\n+\n+ def print_goodbye(self):\n+ \"\"\"Print a styled goodbye message.\"\"\"\n+ print(f\"\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\n\")\n+\n+ # ── Prompt toolkit session factory ────────────────────────────────\n+\n+ def create_prompt_session(self):\n+ \"\"\"Create a prompt_toolkit PromptSession with skin styling.\n+\n+ Returns:\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\n+ \"\"\"\n+ try:\n+ from prompt_toolkit import PromptSession\n+ from prompt_toolkit.history import FileHistory\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\n+\n+ style = self.get_prompt_style()\n+\n+ session = PromptSession(\n+ history=FileHistory(self.history_file),\n+ auto_suggest=AutoSuggestFromHistory(),\n+ style=style,\n+ enable_history_search=True,\n+ )\n+ return session\n+ except ImportError:\n+ return None\n+\n+ def get_input(self, pt_session, project_name: str = \"\",\n+ modified: bool = False, context: str = \"\") -> str:\n+ \"\"\"Get input from user using prompt_toolkit or fallback.\n+\n+ Args:\n+ pt_session: A prompt_toolkit PromptSession (or None).\n+ project_name: Current project name.\n+ modified: Whether project has unsaved changes.\n+ context: Optional context string.\n+\n+ Returns:\n+ User input string (stripped).\n+ \"\"\"\n+ if pt_session is not None:\n+ from prompt_toolkit.formatted_text import FormattedText\n+ tokens = self.prompt_tokens(project_name, modified, context)\n+ return pt_session.prompt(FormattedText(tokens)).strip()\n+ else:\n+ raw_prompt = self.prompt(project_name, modified, context)\n+ return input(raw_prompt).strip()\n+\n+ # ── Toolbar builder ───────────────────────────────────────────────\n+\n+ def bottom_toolbar(self, items: dict[str, str]):\n+ \"\"\"Create a bottom toolbar callback for prompt_toolkit.\n+\n+ Args:\n+ items: Dict of label -> value pairs to show in toolbar.\n+\n+ Returns:\n+ A callable that returns FormattedText for the toolbar.\n+ \"\"\"\n+ def toolbar():\n+ from prompt_toolkit.formatted_text import FormattedText\n+ parts = []\n+ for i, (k, v) in enumerate(items.items()):\n+ if i > 0:\n+ parts.append((\"class:bottom-toolbar.text\", \" │ \"))\n+ parts.append((\"class:bottom-toolbar.text\", f\" {k}: \"))\n+ parts.append((\"class:bottom-toolbar\", v))\n+ return FormattedText(parts)\n+ return toolbar\n+\n+\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\n+\n+_ANSI_256_TO_HEX = {\n+ \"\\033[38;5;33m\": \"#0087ff\", # audacity navy blue\n+ \"\\033[38;5;35m\": \"#00af5f\", # shotcut teal\n+ \"\\033[38;5;39m\": \"#00afff\", # inkscape bright blue\n+ \"\\033[38;5;40m\": \"#00d700\", # libreoffice green\n+ \"\\033[38;5;55m\": \"#5f00af\", # obs purple\n+ \"\\033[38;5;69m\": \"#5f87ff\", # kdenlive slate blue\n+ \"\\033[38;5;75m\": \"#5fafff\", # default sky blue\n+ \"\\033[38;5;80m\": \"#5fd7d7\", # brand cyan\n+ \"\\033[38;5;208m\": \"#ff8700\", # blender deep orange\n+ \"\\033[38;5;214m\": \"#ffaf00\", # gimp warm orange\n+}\n"},{"comment":"The reported test totals for `wavetone` appear inconsistent with the harness’ own `TEST.md` (which documents 9 unit + 5 E2E = 14) and with the added tests (`test_core.py` has 9 tests). Please update this line to reflect the actual current totals.","path":"README.md","hunk":"@@ -1221,6 +1228,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\n blender 208 passed ✅ (150 unit + 58 e2e)\n inkscape 202 passed ✅ (148 unit + 54 e2e)\n audacity 161 passed ✅ (107 unit + 54 e2e)\n+wavetone 13 passed ✅ (8 unit + 5 e2e)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/README.md b/README.md\nindex 17a93d0dd..509e6536b 100644\n--- a/README.md\n+++ b/README.md\n@@ -667,7 +667,7 @@ The meta-skill points agents to the live CLI-Hub catalog, where they can choose\n | **🤖 AI/ML Platforms** | Automate model training, inference pipelines, and hyperparameter tuning through structured commands | Stable Diffusion WebUI, ComfyUI, Ollama, InvokeAI, Text-generation-webui, Open WebUI, Fooocus, Kohya_ss, AnythingLLM, SillyTavern |\n | **📊 Data & Analytics** | Enable programmatic data processing, visualization, and statistical analysis workflows | JupyterLab, Apache Superset, Metabase, Redash, DBeaver, KNIME, Orange, OpenSearch Dashboards, Lightdash |\n | **💻 Development Tools** | Streamline code editing, building, testing, and deployment processes via command interfaces | Jenkins, Gitea, Hoppscotch, Portainer, pgAdmin, SonarQube, ArgoCD, OpenLens, Insomnia, Beekeeper Studio, **[iTerm2](https://iterm2.com)** |\n-| **🎨 Creative & Media** | Control content creation, editing, and rendering workflows programmatically | Blender, GIMP, OBS Studio, Audacity, Krita, Kdenlive, Shotcut, Inkscape, Darktable, LMMS, Ardour |\n+| **🎨 Creative & Media** | Control content creation, editing, and rendering workflows programmatically | Blender, GIMP, OBS Studio, Audacity, WaveTone, Krita, Kdenlive, Shotcut, Inkscape, Darktable, LMMS, Ardour |\n | **🎮 Game Development** | Manage game projects, scenes, exports, and scripting through headless engine interfaces | **[Godot Engine](https://godotengine.org)**, **[s&box](https://sbox.game)** |\n | **🔬 Scientific Computing** | Automate research workflows, simulations, and complex calculations | ImageJ, FreeCAD, QGIS, ParaView, Gephi, LibreCAD, Stellarium, KiCad, JASP, Jamovi |\n | **🏢 Enterprise & Office** | Convert business applications and productivity tools into agent-accessible systems | NextCloud, GitLab, Grafana, Mattermost, LibreOffice, AppFlowy, NocoDB, Odoo (Community), Plane, ERPNext |\n@@ -943,6 +943,13 @@ Each application received complete, production-ready CLI interfaces — not demo\n <td align=\"center\">✅ 161</td>\n </tr>\n <tr>\n+<td align=\"center\"><strong>WaveTone</strong></td>\n+<td>Audio Transcription</td>\n+<td><code>cli-anything-wavetone</code></td>\n+<td>JSON manifest + real WaveTone launch</td>\n+<td align=\"center\"><a href=\"wavetone/agent-harness/\">New</a></td>\n+</tr>\n+<tr>\n <td align=\"center\"><strong>🌐 Browser</strong></td>\n <td>Browser Automation</td>\n <td><code>cli-anything-browser</code></td>\n@@ -1221,6 +1228,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\n blender 208 passed ✅ (150 unit + 58 e2e)\n inkscape 202 passed ✅ (148 unit + 54 e2e)\n audacity 161 passed ✅ (107 unit + 54 e2e)\n+wavetone 30 passed ✅ (24 unit + 6 default e2e, 2 backend-gated e2e skipped; 32 passed opt-in)\n libreoffice 158 passed ✅ (89 unit + 69 e2e)\n mubu 96 passed ✅ (85 unit + 11 e2e)\n obs-studio 153 passed ✅ (116 unit + 37 e2e)\n@@ -1300,6 +1308,7 @@ cli-anything/\n ├── 🧊 blender/agent-harness/ # Blender CLI (208 tests)\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI (202 tests)\n ├── 🎵 audacity/agent-harness/ # Audacity CLI (161 tests)\n+├── wavetone/agent-harness/ # WaveTone CLI (32 tests: 30 default + 2 backend-gated e2e)\n ├── 🌐 browser/agent-harness/ # Browser CLI (DOMShell MCP, new)\n ├── 📄 libreoffice/agent-harness/ # LibreOffice CLI (158 tests)\n ├── 📧 mailchimp/agent-harness/ # Mailchimp Marketing API CLI (303 commands, 36 unit tests)\n"},{"comment":"The WaveTone test counts here likely need to be updated to match the harness test suite and `cli_anything/wavetone/tests/TEST.md` (9 unit + 5 E2E = 14).","path":"README_CN.md","hunk":"@@ -672,6 +679,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\n blender 208 passed ✅ (150 unit + 58 e2e)\n inkscape 202 passed ✅ (148 unit + 54 e2e)\n audacity 161 passed ✅ (107 unit + 54 e2e)\n+wavetone 13 passed ✅ (8 unit + 5 e2e)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/README_CN.md b/README_CN.md\nindex ffac02dd9..6434d70e0 100644\n--- a/README_CN.md\n+++ b/README_CN.md\n@@ -368,7 +368,7 @@ cli-anything-gimp\n | **🤖 AI/ML 平台** | 用结构化命令驱动模型训练、推理流水线和超参搜索 | Stable Diffusion WebUI、ComfyUI、InvokeAI、Text-generation-webui、Open WebUI、Fooocus、Kohya_ss、AnythingLLM、SillyTavern |\n | **📊 数据与分析** | 以编程方式完成数据处理、可视化和统计分析工作流 | JupyterLab、Apache Superset、Metabase、Redash、DBeaver、KNIME、Orange、OpenSearch Dashboards、Lightdash |\n | **💻 开发工具** | 通过 CLI 串联代码编辑、构建、测试与部署流程 | Jenkins、Gitea、Hoppscotch、Portainer、pgAdmin、SonarQube、ArgoCD、OpenLens、Insomnia、Beekeeper Studio |\n-| **🎨 创意与媒体** | 以编程方式控制内容创作、编辑和渲染工作流 | Blender、GIMP、OBS Studio、Audacity、Krita、Kdenlive、Shotcut、Inkscape、Darktable、LMMS、Ardour |\n+| **🎨 创意与媒体** | 以编程方式控制内容创作、编辑和渲染工作流 | Blender、GIMP、OBS Studio、Audacity、WaveTone、Krita、Kdenlive、Shotcut、Inkscape、Darktable、LMMS、Ardour |\n | **📐 图表与可视化** | 以编程方式创建和操作流程图、架构图、ER 图等各类图表 | Draw.io (diagrams.net)、Mermaid、PlantUML、Excalidraw、yEd |\n | **🔬 科学计算** | 自动化科研工作流、仿真模拟和复杂计算 | ImageJ、FreeCAD、QGIS、ParaView、Gephi、LibreCAD、Stellarium、KiCad、JASP、Jamovi |\n | **🏢 企业与办公** | 将商业应用和生产力工具转化为 Agent 可访问的系统 | NextCloud、GitLab、Grafana、Mattermost、LibreOffice、AppFlowy、NocoDB、Odoo (Community)、Plane、ERPNext |\n@@ -534,6 +534,13 @@ CLI-Anything 适用于任何有代码库的软件 —— 不限领域，不限\n <td align=\"center\">✅ 161</td>\n </tr>\n <tr>\n+<td align=\"center\"><strong>WaveTone</strong></td>\n+<td>音频扒谱辅助</td>\n+<td><code>cli-anything-wavetone</code></td>\n+<td>JSON manifest + real WaveTone launch</td>\n+<td align=\"center\"><a href=\"wavetone/agent-harness/\">新增</a></td>\n+</tr>\n+<tr>\n <td align=\"center\"><strong>📄 LibreOffice</strong></td>\n <td>办公套件（Writer、Calc、Impress）</td>\n <td><code>cli-anything-libreoffice</code></td>\n@@ -672,6 +679,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\n blender 208 passed ✅ (150 unit + 58 e2e)\n inkscape 202 passed ✅ (148 unit + 54 e2e)\n audacity 161 passed ✅ (107 unit + 54 e2e)\n+wavetone 30 passed ✅ (24 unit + 6 default e2e，2 backend-gated e2e skipped；32 passed opt-in)\n libreoffice 158 passed ✅ (89 unit + 69 e2e)\n obs-studio 153 passed ✅ (116 unit + 37 e2e)\n kdenlive 155 passed ✅ (111 unit + 44 e2e)\n@@ -745,6 +753,7 @@ cli-anything/\n ├── 🧊 blender/agent-harness/ # Blender CLI（208 项测试）\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI（202 项测试）\n ├── 🎵 audacity/agent-harness/ # Audacity CLI（161 项测试）\n+├── wavetone/agent-harness/ # WaveTone CLI（32 项测试：30 default + 2 backend-gated e2e）\n ├── 📄 libreoffice/agent-harness/ # LibreOffice CLI（158 项测试）\n ├── 📚 zotero/agent-harness/ # Zotero CLI（新增，支持文献导入）\n ├── 📓 joplin/agent-harness/ # Joplin CLI（134 测试：107 单元 + 27 e2e）\n"},{"comment":"**<sub><sub></sub></sub> Preserve inherited JSON mode in nested CLI calls**\n\nWhen the REPL is launched with `cli-anything-wavetone --json`, each command entered inside the REPL is re-dispatched via `cli.main(..., obj=ctx.obj)` without a `--json` option, so `json_mode` is `False` and this assignment overwrites the inherited JSON setting. In that scenario, commands like `defaults` or `audio probe` emit the human-readable `key: value` format instead of machine-readable JSON despite the REPL being started in JSON mode; only replace `ctx.obj[\"json\"]` when the option was explicitly provided, or preserve the existing value for nested invocations.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,347 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ ctx.obj[\"json\"] = json_mode","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"**<sub><sub></sub></sub> Handle EOFError from malformed WAV files**\n\nFor empty or truncated `.wav`/`.wave` inputs, `wave.open()` can raise `EOFError` rather than `wave.Error`; in that case `probe_audio()` bypasses the ffprobe/stat fallback and the CLI exits as an abort even in `--json` mode. This affects existing files with a supported WAV extension whose header is incomplete, so include `EOFError` in the fallback path or convert it to a Click error.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/core/audio.py","hunk":"@@ -0,0 +1,96 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels\",\n+ \"-show_entries\",\n+ \"format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = float(fmt.get(\"duration\") or 0.0)\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": int(audio_stream[\"sample_rate\"]) if audio_stream.get(\"sample_rate\") else None,\n+ \"channels\": audio_stream.get(\"channels\"),\n+ \"bit_rate\": int(fmt[\"bit_rate\"]) if fmt.get(\"bit_rate\") else None,\n+ \"size_bytes\": int(fmt.get(\"size\") or path.stat().st_size),\n+ \"probe_method\": \"ffprobe\",\n+ }\n+\n+\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\n+ path = normalize_audio_path(audio_path)\n+ if path.suffix.lower() in {\".wav\", \".wave\"}:\n+ try:\n+ return _probe_wav_stdlib(path)\n+ except wave.Error:","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\nnew file mode 100644\nindex 000000000..f35f343f5\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\n@@ -0,0 +1,112 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _safe_float(value: Any) -> float | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return float(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _safe_int(value: Any) -> int | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return int(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = _safe_float(fmt.get(\"duration\"))\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6) if duration is not None else None,\n+ \"sample_rate\": _safe_int(audio_stream.get(\"sample_rate\")),\n+ \"channels\": _safe_int(audio_stream.get(\"channels\")),\n+ \"bit_rate\": _safe_int(fmt.get(\"bit_rate\")),\n+ \"size_bytes\": _safe_int(fmt.get(\"size\")) or path.stat().st_size,\n+ \"probe_method\": \"ffprobe\",\n+ }\n+\n+\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\n+ path = normalize_audio_path(audio_path)\n+ if path.suffix.lower() in {\".wav\", \".wave\"}:\n+ try:\n+ return _probe_wav_stdlib(path)\n+ except (wave.Error, EOFError):\n+ pass\n+ try:\n+ return _probe_ffprobe(path)\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\n+ return {\n+ \"path\": str(path),\n+ \"format\": path.suffix.lower().lstrip(\".\") or None,\n+ \"codec\": None,\n+ \"duration_seconds\": None,\n+ \"sample_rate\": None,\n+ \"channels\": None,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"stat\",\n+ \"warning\": \"Install ffprobe for detailed metadata on this format.\",\n+ }\n"},{"comment":"`ffprobe`’s `-show_entries` is typically provided once (with multiple sections separated by `:`). Passing it twice can result in only the latter taking effect on some ffprobe builds, which would make `streams` missing and break the `audio_stream` extraction. Combine the entries into a single `-show_entries` argument (e.g., `stream=...:format=...`) to make the probe reliable.","path":"wavetone/agent-harness/cli_anything/wavetone/core/audio.py","hunk":"@@ -0,0 +1,96 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels\",\n+ \"-show_entries\",\n+ \"format=duration,format_name,bit_rate,size\",","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\nnew file mode 100644\nindex 000000000..f35f343f5\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\n@@ -0,0 +1,112 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _safe_float(value: Any) -> float | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return float(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _safe_int(value: Any) -> int | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return int(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = _safe_float(fmt.get(\"duration\"))\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6) if duration is not None else None,\n+ \"sample_rate\": _safe_int(audio_stream.get(\"sample_rate\")),\n+ \"channels\": _safe_int(audio_stream.get(\"channels\")),\n+ \"bit_rate\": _safe_int(fmt.get(\"bit_rate\")),\n+ \"size_bytes\": _safe_int(fmt.get(\"size\")) or path.stat().st_size,\n+ \"probe_method\": \"ffprobe\",\n+ }\n+\n+\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\n+ path = normalize_audio_path(audio_path)\n+ if path.suffix.lower() in {\".wav\", \".wave\"}:\n+ try:\n+ return _probe_wav_stdlib(path)\n+ except (wave.Error, EOFError):\n+ pass\n+ try:\n+ return _probe_ffprobe(path)\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\n+ return {\n+ \"path\": str(path),\n+ \"format\": path.suffix.lower().lstrip(\".\") or None,\n+ \"codec\": None,\n+ \"duration_seconds\": None,\n+ \"sample_rate\": None,\n+ \"channels\": None,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"stat\",\n+ \"warning\": \"Install ffprobe for detailed metadata on this format.\",\n+ }\n"},{"comment":"If the existing session file contains valid JSON that is not an object (e.g., a list/string/number), `data.setdefault(...)` will raise `AttributeError`, which is not caught by the CLI handlers (they catch `ValueError`/`JSONDecodeError`). Validate `data` is a `dict` (and that `events` is a list) after `json.loads`, and raise a `ValueError` with a clear message when the schema is invalid.","path":"wavetone/agent-harness/cli_anything/wavetone/core/session.py","hunk":"@@ -0,0 +1,30 @@\n+\"\"\"Small session event log for WaveTone CLI runs.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import now_iso\n+\n+\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\n+ path = Path(session_path).expanduser().resolve()\n+ if path.exists():\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ else:\n+ data = {\"schema_version\": \"wavetone-session/v1\", \"events\": []}\n+ record = {\"time\": now_iso(), \"event\": event, \"payload\": payload}\n+ data.setdefault(\"events\", []).append(record)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/session.py b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\nnew file mode 100644\nindex 000000000..d9f2c7f26\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\n@@ -0,0 +1,61 @@\n+\"\"\"Small session event log for WaveTone CLI runs.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import now_iso\n+\n+\n+def _new_session() -> dict[str, Any]:\n+ return {\"schema_version\": \"wavetone-session/v1\", \"events\": []}\n+\n+\n+def _assert_json_safe(value: Any, path: str = \"payload\") -> None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{path} must contain only finite numbers\")\n+ if isinstance(value, dict):\n+ for key, item in value.items():\n+ _assert_json_safe(item, f\"{path}.{key}\")\n+ elif isinstance(value, list):\n+ for idx, item in enumerate(value):\n+ _assert_json_safe(item, f\"{path}[{idx}]\")\n+\n+\n+def _load_session_data(path: Path) -> dict[str, Any]:\n+ if not path.exists():\n+ return _new_session()\n+\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Session file must be a JSON object\")\n+\n+ events = data.get(\"events\")\n+ if events is None:\n+ data[\"events\"] = []\n+ elif not isinstance(events, list):\n+ raise ValueError(\"Session file field 'events' must be a list\")\n+\n+ return data\n+\n+\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\n+ path = Path(session_path).expanduser().resolve()\n+ data = _load_session_data(path)\n+ _assert_json_safe(payload)\n+ record = {\"time\": now_iso(), \"event\": event, \"payload\": payload}\n+ data[\"events\"].append(record)\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return record\n+\n+\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\n+ path = Path(session_path).expanduser().resolve()\n+ if not path.exists():\n+ return []\n+ data = _load_session_data(path)\n+ return list(data[\"events\"])\n"},{"comment":"Similar to `append_event`, if the session JSON is valid but not a dict, `data.get(...)` will raise `AttributeError`, which again won’t be converted into a `click.ClickException` by callers that only catch `ValueError`/`JSONDecodeError`. Add a type/schema check after loading and raise `ValueError` when the structure is not `{ \"events\": [...] }`.","path":"wavetone/agent-harness/cli_anything/wavetone/core/session.py","hunk":"@@ -0,0 +1,30 @@\n+\"\"\"Small session event log for WaveTone CLI runs.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import now_iso\n+\n+\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\n+ path = Path(session_path).expanduser().resolve()\n+ if path.exists():\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ else:\n+ data = {\"schema_version\": \"wavetone-session/v1\", \"events\": []}\n+ record = {\"time\": now_iso(), \"event\": event, \"payload\": payload}\n+ data.setdefault(\"events\", []).append(record)\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True) + \"\\n\", encoding=\"utf-8\")\n+ return record\n+\n+\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\n+ path = Path(session_path).expanduser().resolve()\n+ if not path.exists():\n+ return []\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ return list(data.get(\"events\", []))","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/session.py b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\nnew file mode 100644\nindex 000000000..d9f2c7f26\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\n@@ -0,0 +1,61 @@\n+\"\"\"Small session event log for WaveTone CLI runs.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import now_iso\n+\n+\n+def _new_session() -> dict[str, Any]:\n+ return {\"schema_version\": \"wavetone-session/v1\", \"events\": []}\n+\n+\n+def _assert_json_safe(value: Any, path: str = \"payload\") -> None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{path} must contain only finite numbers\")\n+ if isinstance(value, dict):\n+ for key, item in value.items():\n+ _assert_json_safe(item, f\"{path}.{key}\")\n+ elif isinstance(value, list):\n+ for idx, item in enumerate(value):\n+ _assert_json_safe(item, f\"{path}[{idx}]\")\n+\n+\n+def _load_session_data(path: Path) -> dict[str, Any]:\n+ if not path.exists():\n+ return _new_session()\n+\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Session file must be a JSON object\")\n+\n+ events = data.get(\"events\")\n+ if events is None:\n+ data[\"events\"] = []\n+ elif not isinstance(events, list):\n+ raise ValueError(\"Session file field 'events' must be a list\")\n+\n+ return data\n+\n+\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\n+ path = Path(session_path).expanduser().resolve()\n+ data = _load_session_data(path)\n+ _assert_json_safe(payload)\n+ record = {\"time\": now_iso(), \"event\": event, \"payload\": payload}\n+ data[\"events\"].append(record)\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return record\n+\n+\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\n+ path = Path(session_path).expanduser().resolve()\n+ if not path.exists():\n+ return []\n+ data = _load_session_data(path)\n+ return list(data[\"events\"])\n"},{"comment":"`find_namespace_packages(include=[\"cli_anything.*\"])` will also package `cli_anything.wavetone.tests` because it has an `__init__.py`. Shipping tests in the installable distribution is usually undesirable (larger wheels, extra dependencies, and accidental import surface). Exclude the test package (and any other non-runtime packages) via `exclude=[...]` or by tightening the include patterns.","path":"wavetone/agent-harness/setup.py","hunk":"@@ -0,0 +1,46 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ packages=find_namespace_packages(include=[\"cli_anything.*\"]),","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\nnew file mode 100644\nindex 000000000..4821f34d0\n--- /dev/null\n+++ b/wavetone/agent-harness/setup.py\n@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ packages=find_namespace_packages(\n+ include=[\"cli_anything.*\"],\n+ exclude=[\"cli_anything.*.tests\", \"cli_anything.*.tests.*\"],\n+ ),\n+ classifiers=[\n+ \"Development Status :: 4 - Beta\",\n+ \"Intended Audience :: Developers\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Analysis\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Editors\",\n+ \"License :: OSI Approved :: MIT License\",\n+ \"Programming Language :: Python :: 3\",\n+ \"Programming Language :: Python :: 3.10\",\n+ \"Programming Language :: Python :: 3.11\",\n+ \"Programming Language :: Python :: 3.12\",\n+ \"Operating System :: Microsoft :: Windows\",\n+ ],\n+ python_requires=\">=3.10\",\n+ install_requires=[\"click>=8.0.0\", \"prompt-toolkit>=3.0.0\"],\n+ extras_require={\"dev\": [\"pytest>=7.0.0\"]},\n+ entry_points={\n+ \"console_scripts\": [\n+ \"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\",\n+ ],\n+ },\n+ package_data={\"cli_anything.wavetone\": [\"README.md\", \"skills/SKILL.md\", \"skills/*.md\"]},\n+ include_package_data=True,\n+ zip_safe=False,\n+)\n"},{"comment":"**<sub><sub></sub></sub> Fail launch smoke checks on early process exit**\n\nWhen `wavetone launch --wait ...` is used as the documented smoke check and the executable starts but immediately exits (for example because a bundled DLL is missing or the GUI fails during startup), `launch_wavetone()` returns `running_after_wait: false` and the nonzero `exit_code`, but this wrapper still emits `ok: True` and exits 0 unconditionally. I reproduced this with a fake `wavetone.exe` that exits 42; CI or agents relying on the recommended launch command's exit status would accept a failed backend launch instead of surfacing it.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,350 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"wavetone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = shlex.split(line, posix=(os.name != \"nt\"))\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental/--no-fundamental\", default=None)\n+@click.option(\"--skip-dialog/--show-dialog\", default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"launch\": data}, ctx_json(ctx))","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"`ffprobe` commonly returns `\"N/A\"` (or other non-numeric strings) for fields like `duration`, `bit_rate`, `size`, and `sample_rate`. As written, `float(...)` / `int(...)` can raise `ValueError`, which is not caught by `probe_audio()` (it only catches `RuntimeError`, `CalledProcessError`, `JSONDecodeError`), causing the CLI to fail unexpectedly. Consider adding safe numeric parsing (e.g., helper that returns `None` for missing/invalid values, including `\"N/A\"`) and/or expanding the caller’s exception handling so invalid numeric fields fall back to `\"stat\"` probing rather than crashing.","path":"wavetone/agent-harness/cli_anything/wavetone/core/audio.py","hunk":"@@ -0,0 +1,94 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = float(fmt.get(\"duration\") or 0.0)\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": int(audio_stream[\"sample_rate\"]) if audio_stream.get(\"sample_rate\") else None,\n+ \"channels\": audio_stream.get(\"channels\"),\n+ \"bit_rate\": int(fmt[\"bit_rate\"]) if fmt.get(\"bit_rate\") else None,\n+ \"size_bytes\": int(fmt.get(\"size\") or path.stat().st_size),\n+ \"probe_method\": \"ffprobe\",\n+ }","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\nnew file mode 100644\nindex 000000000..f35f343f5\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\n@@ -0,0 +1,112 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _safe_float(value: Any) -> float | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return float(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _safe_int(value: Any) -> int | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return int(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = _safe_float(fmt.get(\"duration\"))\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6) if duration is not None else None,\n+ \"sample_rate\": _safe_int(audio_stream.get(\"sample_rate\")),\n+ \"channels\": _safe_int(audio_stream.get(\"channels\")),\n+ \"bit_rate\": _safe_int(fmt.get(\"bit_rate\")),\n+ \"size_bytes\": _safe_int(fmt.get(\"size\")) or path.stat().st_size,\n+ \"probe_method\": \"ffprobe\",\n+ }\n+\n+\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\n+ path = normalize_audio_path(audio_path)\n+ if path.suffix.lower() in {\".wav\", \".wave\"}:\n+ try:\n+ return _probe_wav_stdlib(path)\n+ except (wave.Error, EOFError):\n+ pass\n+ try:\n+ return _probe_ffprobe(path)\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\n+ return {\n+ \"path\": str(path),\n+ \"format\": path.suffix.lower().lstrip(\".\") or None,\n+ \"codec\": None,\n+ \"duration_seconds\": None,\n+ \"sample_rate\": None,\n+ \"channels\": None,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"stat\",\n+ \"warning\": \"Install ffprobe for detailed metadata on this format.\",\n+ }\n"},{"comment":"The packaged skill file is `skills/SKILL.md` (uppercase extension). On case-sensitive filesystems (common for Linux build agents), the glob `skills/*.md` will not match `SKILL.md`, so the skill file won’t be included in wheels/sdists. Include the exact filename (e.g., `skills/SKILL.md`) and/or broaden the pattern to cover both cases so agents relying on packaged skill discovery don’t lose the documentation.","path":"wavetone/agent-harness/setup.py","hunk":"@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ packages=find_namespace_packages(\n+ include=[\"cli_anything.*\"],\n+ exclude=[\"cli_anything.*.tests\", \"cli_anything.*.tests.*\"],\n+ ),\n+ classifiers=[\n+ \"Development Status :: 4 - Beta\",\n+ \"Intended Audience :: Developers\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Analysis\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Editors\",\n+ \"License :: OSI Approved :: MIT License\",\n+ \"Programming Language :: Python :: 3\",\n+ \"Programming Language :: Python :: 3.10\",\n+ \"Programming Language :: Python :: 3.11\",\n+ \"Programming Language :: Python :: 3.12\",\n+ \"Operating System :: Microsoft :: Windows\",\n+ ],\n+ python_requires=\">=3.10\",\n+ install_requires=[\"click>=8.0.0\", \"prompt-toolkit>=3.0.0\"],\n+ extras_require={\"dev\": [\"pytest>=7.0.0\"]},\n+ entry_points={\n+ \"console_scripts\": [\n+ \"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\",\n+ ],\n+ },\n+ package_data={\"cli_anything.wavetone\": [\"skills/*.md\"]},","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\nnew file mode 100644\nindex 000000000..4821f34d0\n--- /dev/null\n+++ b/wavetone/agent-harness/setup.py\n@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ packages=find_namespace_packages(\n+ include=[\"cli_anything.*\"],\n+ exclude=[\"cli_anything.*.tests\", \"cli_anything.*.tests.*\"],\n+ ),\n+ classifiers=[\n+ \"Development Status :: 4 - Beta\",\n+ \"Intended Audience :: Developers\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Analysis\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Editors\",\n+ \"License :: OSI Approved :: MIT License\",\n+ \"Programming Language :: Python :: 3\",\n+ \"Programming Language :: Python :: 3.10\",\n+ \"Programming Language :: Python :: 3.11\",\n+ \"Programming Language :: Python :: 3.12\",\n+ \"Operating System :: Microsoft :: Windows\",\n+ ],\n+ python_requires=\">=3.10\",\n+ install_requires=[\"click>=8.0.0\", \"prompt-toolkit>=3.0.0\"],\n+ extras_require={\"dev\": [\"pytest>=7.0.0\"]},\n+ entry_points={\n+ \"console_scripts\": [\n+ \"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\",\n+ ],\n+ },\n+ package_data={\"cli_anything.wavetone\": [\"README.md\", \"skills/SKILL.md\", \"skills/*.md\"]},\n+ include_package_data=True,\n+ zip_safe=False,\n+)\n"},{"comment":"This harness is documented as Windows-only, but `launch_wavetone()` will attempt `subprocess.Popen()` on any platform and then fail with a low-level OS error (e.g., exec format error). Adding an explicit platform guard (similar to `doctor()`’s Windows check) and raising a clear exception (e.g., `RuntimeError(\"WaveTone launch requires Windows\")`) will make failures more actionable in CI/non-Windows environments.","path":"wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py","hunk":"@@ -0,0 +1,160 @@\n+\"\"\"Backend wrapper for the real WaveTone 2.61 executable.\"\"\"\n+\n+from __future__ import annotations\n+\n+import os\n+import platform\n+import subprocess\n+import time\n+from pathlib import Path\n+from typing import Any\n+\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\n+\n+\n+REQUIRED_DATA_FILES = [\n+ \"awlib.dll\",\n+ \"bass.dll\",\n+ \"bassflac.dll\",\n+ \"basswma.dll\",\n+ \"basswv.dll\",\n+ \"bass_aac.dll\",\n+ \"bass_alac.dll\",\n+ \"bass_ape.dll\",\n+ \"bass_tta.dll\",\n+ \"asdecoder.exe\",\n+]\n+\n+\n+def default_candidates() -> list[Path]:\n+ candidates: list[Path] = []\n+ env_exe = os.environ.get(\"WAVETONE_EXE\")\n+ if env_exe:\n+ candidates.append(Path(env_exe))\n+ env_home = os.environ.get(\"WAVETONE_HOME\")\n+ if env_home:\n+ candidates.append(Path(env_home) / \"wavetone.exe\")\n+ candidates.append(Path(env_home) / \"WaveTone.exe\")\n+ home = Path.home()\n+ candidates.extend(\n+ [\n+ home / \"Desktop\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ home / \"Downloads\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ Path(\"C:/Program Files/WaveTone/wavetone.exe\"),\n+ Path(\"C:/Program Files (x86)/WaveTone/wavetone.exe\"),\n+ ]\n+ )\n+ return candidates\n+\n+\n+def find_wavetone(executable: str | Path | None = None) -> Path:\n+ candidates = [Path(executable)] if executable else default_candidates()\n+ checked: list[str] = []\n+ for candidate in candidates:\n+ path = candidate.expanduser()\n+ checked.append(str(path))\n+ if path.exists() and path.is_file():\n+ return path.resolve()\n+ raise FileNotFoundError(\n+ \"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \"\n+ \"WAVETONE_HOME to the extracted WaveTone directory. Checked: \"\n+ + \"; \".join(checked)\n+ )\n+\n+\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\n+ checks: list[dict[str, Any]] = []\n+ try:\n+ exe = find_wavetone(executable)\n+ root = exe.parent\n+ checks.append({\"name\": \"wavetone executable\", \"ok\": True, \"path\": str(exe)})\n+ except FileNotFoundError as exc:\n+ return {\n+ \"ready\": False,\n+ \"platform\": platform.system(),\n+ \"checks\": [{\"name\": \"wavetone executable\", \"ok\": False, \"error\": str(exc)}],\n+ }\n+\n+ data_dir = root / \"data\"\n+ checks.append({\"name\": \"data directory\", \"ok\": data_dir.is_dir(), \"path\": str(data_dir)})\n+ for filename in REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ checks.append({\"name\": f\"data/{filename}\", \"ok\": path.exists(), \"path\": str(path)})\n+ help_dir = root / \"wthelp\"\n+ checks.append({\"name\": \"help directory\", \"ok\": help_dir.is_dir(), \"path\": str(help_dir)})\n+ checks.append(\n+ {\n+ \"name\": \"windows host\",\n+ \"ok\": platform.system().lower() == \"windows\",\n+ \"platform\": platform.platform(),\n+ }\n+ )\n+ return {\n+ \"ready\": all(check[\"ok\"] for check in checks),\n+ \"platform\": platform.system(),\n+ \"root\": str(root),\n+ \"checks\": checks,\n+ }\n+\n+\n+def launch_wavetone(\n+ audio_path: str | Path | None = None,\n+ executable: str | Path | None = None,\n+ wait_seconds: float = 0.0,\n+ terminate: bool = False,\n+) -> dict[str, Any]:\n+ exe = find_wavetone(executable)\n+ args = [str(exe)]\n+ audio: Path | None = None\n+ if audio_path:\n+ audio = normalize_audio_path(audio_path)\n+ args.append(str(audio))\n+\n+ process = subprocess.Popen(args, cwd=str(exe.parent))","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\nnew file mode 100644\nindex 000000000..81d3d35ec\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\n@@ -0,0 +1,163 @@\n+\"\"\"Backend wrapper for the real WaveTone 2.61 executable.\"\"\"\n+\n+from __future__ import annotations\n+\n+import os\n+import platform\n+import subprocess\n+import time\n+from pathlib import Path\n+from typing import Any\n+\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\n+\n+\n+REQUIRED_DATA_FILES = [\n+ \"awlib.dll\",\n+ \"bass.dll\",\n+ \"bassflac.dll\",\n+ \"basswma.dll\",\n+ \"basswv.dll\",\n+ \"bass_aac.dll\",\n+ \"bass_alac.dll\",\n+ \"bass_ape.dll\",\n+ \"bass_tta.dll\",\n+ \"asdecoder.exe\",\n+]\n+\n+\n+def default_candidates() -> list[Path]:\n+ candidates: list[Path] = []\n+ env_exe = os.environ.get(\"WAVETONE_EXE\")\n+ if env_exe:\n+ candidates.append(Path(env_exe))\n+ env_home = os.environ.get(\"WAVETONE_HOME\")\n+ if env_home:\n+ candidates.append(Path(env_home) / \"wavetone.exe\")\n+ candidates.append(Path(env_home) / \"WaveTone.exe\")\n+ home = Path.home()\n+ candidates.extend(\n+ [\n+ home / \"Desktop\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ home / \"Downloads\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ Path(\"C:/Program Files/WaveTone/wavetone.exe\"),\n+ Path(\"C:/Program Files (x86)/WaveTone/wavetone.exe\"),\n+ ]\n+ )\n+ return candidates\n+\n+\n+def find_wavetone(executable: str | Path | None = None) -> Path:\n+ candidates = [Path(executable)] if executable else default_candidates()\n+ checked: list[str] = []\n+ for candidate in candidates:\n+ path = candidate.expanduser()\n+ checked.append(str(path))\n+ if path.exists() and path.is_file():\n+ return path.resolve()\n+ raise FileNotFoundError(\n+ \"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \"\n+ \"WAVETONE_HOME to the extracted WaveTone directory. Checked: \"\n+ + \"; \".join(checked)\n+ )\n+\n+\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\n+ checks: list[dict[str, Any]] = []\n+ try:\n+ exe = find_wavetone(executable)\n+ root = exe.parent\n+ checks.append({\"name\": \"wavetone executable\", \"ok\": True, \"path\": str(exe)})\n+ except FileNotFoundError as exc:\n+ return {\n+ \"ready\": False,\n+ \"platform\": platform.system(),\n+ \"checks\": [{\"name\": \"wavetone executable\", \"ok\": False, \"error\": str(exc)}],\n+ }\n+\n+ data_dir = root / \"data\"\n+ checks.append({\"name\": \"data directory\", \"ok\": data_dir.is_dir(), \"path\": str(data_dir)})\n+ for filename in REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ checks.append({\"name\": f\"data/{filename}\", \"ok\": path.is_file(), \"path\": str(path)})\n+ help_dir = root / \"wthelp\"\n+ checks.append({\"name\": \"help directory\", \"ok\": help_dir.is_dir(), \"path\": str(help_dir)})\n+ checks.append(\n+ {\n+ \"name\": \"windows host\",\n+ \"ok\": platform.system().lower() == \"windows\",\n+ \"platform\": platform.platform(),\n+ }\n+ )\n+ return {\n+ \"ready\": all(check[\"ok\"] for check in checks),\n+ \"platform\": platform.system(),\n+ \"root\": str(root),\n+ \"checks\": checks,\n+ }\n+\n+\n+def launch_wavetone(\n+ audio_path: str | Path | None = None,\n+ executable: str | Path | None = None,\n+ wait_seconds: float = 0.0,\n+ terminate: bool = False,\n+) -> dict[str, Any]:\n+ if platform.system().lower() != \"windows\":\n+ raise RuntimeError(\"WaveTone launch requires Windows\")\n+\n+ exe = find_wavetone(executable)\n+ args = [str(exe)]\n+ audio: Path | None = None\n+ if audio_path:\n+ audio = normalize_audio_path(audio_path)\n+ args.append(str(audio))\n+\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\n+ if wait_seconds > 0:\n+ time.sleep(wait_seconds)\n+ polled = process.poll()\n+ running_after_wait = polled is None\n+ exit_code = polled\n+ terminated = False\n+ if terminate and running_after_wait:\n+ process.terminate()\n+ try:\n+ process.wait(timeout=3)\n+ except subprocess.TimeoutExpired:\n+ process.kill()\n+ process.wait(timeout=3)\n+ terminated = True\n+ exit_code = process.returncode\n+\n+ return {\n+ \"backend\": \"wavetone.exe\",\n+ \"executable\": str(exe),\n+ \"cwd\": str(exe.parent),\n+ \"pid\": process.pid,\n+ \"args\": args,\n+ \"audio_path\": str(audio) if audio else None,\n+ \"running_after_wait\": running_after_wait,\n+ \"terminated\": terminated,\n+ \"exit_code\": exit_code,\n+ \"note\": \"WaveTone analysis and export dialogs are GUI driven in version 2.61.\",\n+ }\n+\n+\n+def supported_formats() -> dict[str, Any]:\n+ return {\n+ \"extensions\": sorted(SUPPORTED_AUDIO_EXTENSIONS),\n+ \"from_readme\": [\n+ \"WAVE\",\n+ \"AIFF\",\n+ \"MP3\",\n+ \"WMA\",\n+ \"AAC\",\n+ \"Vorbis\",\n+ \"FLAC\",\n+ \"WavPack\",\n+ \"Monkey's Audio\",\n+ \"ALAC\",\n+ \"TTA\",\n+ ],\n+ }\n"},{"comment":"`make_wav()` is duplicated in `test_core.py` and `test_full_e2e.py` with slightly different defaults. To reduce duplication and keep fixtures consistent, consider moving it into a shared test utility module or a pytest fixture and importing it from both test files.","path":"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py","hunk":"@@ -0,0 +1,137 @@\n+from __future__ import annotations\n+\n+import json\n+import math\n+import os\n+import shutil\n+import struct\n+import subprocess\n+import sys\n+import wave\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+\n+def make_wav(path: Path, freq: float = 440.0, duration: float = 0.5, sample_rate: int = 8000) -> Path:\n+ frames = int(duration * sample_rate)\n+ with wave.open(str(path), \"wb\") as handle:\n+ handle.setnchannels(1)\n+ handle.setsampwidth(2)\n+ handle.setframerate(sample_rate)\n+ for idx in range(frames):\n+ sample = int(16000 * math.sin(2 * math.pi * freq * idx / sample_rate))\n+ handle.writeframes(struct.pack(\"<h\", sample))\n+ return path","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2ceb45661\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\n@@ -0,0 +1,153 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\n+ \"\"\"Run the in-tree module by default; installed entry points are opt-in.\"\"\"\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ if not force_installed:\n+ print(f\"[_resolve_cli] Using source module: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+ path = shutil.which(name)\n+ if not path:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+\n+\n+def _env_flag_enabled(name: str) -> bool:\n+ return os.environ.get(name, \"\").strip().lower() in {\"1\", \"true\", \"yes\", \"on\"}\n+\n+\n+def _real_backend_ready() -> tuple[bool, str]:\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\n+ return False, f\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+ if sys.platform != \"win32\":\n+ return False, \"WaveTone real-backend tests require Windows\"\n+ if not (os.environ.get(\"WAVETONE_EXE\") or os.environ.get(\"WAVETONE_HOME\")):\n+ return False, \"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+\n+ status = wavetone_backend.doctor()\n+ if status.get(\"ready\"):\n+ return True, \"\"\n+\n+ failed_checks = [check[\"name\"] for check in status.get(\"checks\", []) if not check.get(\"ok\")]\n+ reason = \", \".join(failed_checks) if failed_checks else \"WaveTone backend is not ready\"\n+ return False, f\"WaveTone real backend unavailable: {reason}\"\n+\n+\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\n+\n+\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\n+ monkeypatch.delenv(\"WAVETONE_EXE\", raising=False)\n+ monkeypatch.delenv(\"WAVETONE_HOME\", raising=False)\n+\n+ ready, reason = _real_backend_ready()\n+\n+ assert ready is False\n+ assert REAL_BACKEND_ENV in reason\n+\n+\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setenv(\"CLI_ANYTHING_FORCE_INSTALLED\", \"1\")\n+ monkeypatch.setattr(shutil, \"which\", lambda name: pytest.fail(\"default resolver should not inspect PATH\"))\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\") == [sys.executable, \"-m\", \"cli_anything.wavetone.wavetone_cli\"]\n+\n+\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setattr(shutil, \"which\", lambda name: \"C:/installed/cli-anything-wavetone.exe\")\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\", force_installed=True) == [\"C:/installed/cli-anything-wavetone.exe\"]\n+\n+\n+class TestCLISubprocess:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\n+class TestRealWaveToneBackend:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"ready\"] is True\n+ assert any(check[\"name\"] == \"data/asdecoder.exe\" and check[\"ok\"] for check in data[\"checks\"])\n+ print(f\"\\n WaveTone root: {data['root']}\")\n+\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\n+ exe = wavetone_backend.find_wavetone()\n+ wav = make_wav(tmp_path / \"launch.wav\")\n+ result = self._run(\n+ [\n+ \"--json\",\n+ \"wavetone\",\n+ \"launch\",\n+ str(wav),\n+ \"--exe\",\n+ str(exe),\n+ \"--wait\",\n+ \"1\",\n+ \"--terminate\",\n+ ]\n+ )\n+ data = json.loads(result.stdout)[\"launch\"]\n+ assert data[\"backend\"] == \"wavetone.exe\"\n+ assert data[\"audio_path\"] == str(wav.resolve())\n+ assert data[\"running_after_wait\"] is True\n+ assert data[\"terminated\"] is True\n+ print(f\"\\n Launched WaveTone PID: {data['pid']}\")\n+ print(f\" WAV: {wav} ({wav.stat().st_size:,} bytes)\")\n"},{"comment":"**<sub><sub></sub></sub> Reject non-finite values before writing JSON**\n\nWhen any float-valued command path stores `nan` or `inf` in the manifest (for example `project set-tempo --bpm nan` or `project analysis --reference-frequency-hz inf`), this `json.dumps` call uses Python's default `allow_nan=True` and writes `NaN`/`Infinity` tokens into the `.wt.json` file. Those tokens are not valid JSON, so strict consumers of the agent-facing manifest or `--json` output can no longer parse the result; validate finite numeric inputs or serialize with `allow_nan=False` so the command fails instead of corrupting the manifest.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/core/project.py","hunk":"@@ -0,0 +1,172 @@\n+\"\"\"Project manifest helpers for the WaveTone harness.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+from copy import deepcopy\n+from datetime import datetime, timezone\n+from pathlib import Path\n+from typing import Any\n+\n+\n+SCHEMA_VERSION = \"wavetone-project/v1\"\n+SOFTWARE_VERSION = \"2.61\"\n+SUPPORTED_AUDIO_EXTENSIONS = {\n+ \".wav\",\n+ \".wave\",\n+ \".aif\",\n+ \".aiff\",\n+ \".mp3\",\n+ \".wma\",\n+ \".aac\",\n+ \".ogg\",\n+ \".oga\",\n+ \".flac\",\n+ \".wv\",\n+ \".ape\",\n+ \".alac\",\n+ \".tta\",\n+}\n+\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\n+ \"blocks_per_second\": 12,\n+ \"blocks_per_semitone\": 5,\n+ \"note_range\": \"C1-B7\",\n+ \"reference_frequency_hz\": 440.0,\n+ \"analyze_fundamental_frequency\": True,\n+ \"channel\": \"Stereo\",\n+ \"skip_analysis_dialog\": False,\n+}\n+\n+\n+def now_iso() -> str:\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\n+\n+\n+def normalize_audio_path(audio_path: str | Path) -> Path:\n+ path = Path(audio_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Audio file not found: {path}\")\n+ if not path.is_file():\n+ raise ValueError(f\"Audio path is not a file: {path}\")\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\n+ supported = \", \".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\n+ raise ValueError(f\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\")\n+ return path\n+\n+\n+def create_project(\n+ audio_path: str | Path,\n+ name: str | None = None,\n+ analysis_settings: dict[str, Any] | None = None,\n+) -> dict[str, Any]:\n+ audio = normalize_audio_path(audio_path)\n+ created_at = now_iso()\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\n+ if analysis_settings:\n+ settings.update(analysis_settings)\n+\n+ return {\n+ \"schema_version\": SCHEMA_VERSION,\n+ \"software\": {\"name\": \"WaveTone\", \"version\": SOFTWARE_VERSION, \"backend\": \"wavetone.exe\"},\n+ \"project\": {\"name\": name or audio.stem, \"created_at\": created_at, \"modified_at\": created_at},\n+ \"audio\": {\n+ \"path\": str(audio),\n+ \"filename\": audio.name,\n+ \"extension\": audio.suffix.lower(),\n+ \"size_bytes\": audio.stat().st_size,\n+ },\n+ \"analysis\": settings,\n+ \"tempo\": {\"bpm\": None, \"first_bar_time_seconds\": 0.0, \"meter\": \"4/4\"},\n+ \"labels\": [],\n+ \"notes\": [],\n+ \"wfd_path\": None,\n+ \"limitations\": [\n+ \"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\",\n+ \"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\",\n+ ],\n+ }\n+\n+\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\n+ project.setdefault(\"project\", {})[\"modified_at\"] = now_iso()\n+ return project\n+\n+\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\n+ path = Path(output_path).expanduser().resolve()\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ touch(project)\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True) + \"\\n\", encoding=\"utf-8\")","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/project.py b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\nnew file mode 100644\nindex 000000000..7e06d8e07\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\n@@ -0,0 +1,187 @@\n+\"\"\"Project manifest helpers for the WaveTone harness.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from copy import deepcopy\n+from datetime import datetime, timezone\n+from pathlib import Path\n+from typing import Any\n+\n+\n+SCHEMA_VERSION = \"wavetone-project/v1\"\n+SOFTWARE_VERSION = \"2.61\"\n+SUPPORTED_AUDIO_EXTENSIONS = {\n+ \".wav\",\n+ \".wave\",\n+ \".aif\",\n+ \".aiff\",\n+ \".mp3\",\n+ \".wma\",\n+ \".aac\",\n+ \".ogg\",\n+ \".oga\",\n+ \".flac\",\n+ \".wv\",\n+ \".ape\",\n+ \".alac\",\n+ \".tta\",\n+}\n+\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\n+ \"blocks_per_second\": 12,\n+ \"blocks_per_semitone\": 5,\n+ \"note_range\": \"C1-B7\",\n+ \"reference_frequency_hz\": 440.0,\n+ \"analyze_fundamental_frequency\": True,\n+ \"channel\": \"Stereo\",\n+ \"skip_analysis_dialog\": False,\n+}\n+\n+\n+def now_iso() -> str:\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\n+\n+\n+def normalize_audio_path(audio_path: str | Path) -> Path:\n+ path = Path(audio_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Audio file not found: {path}\")\n+ if not path.is_file():\n+ raise ValueError(f\"Audio path is not a file: {path}\")\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\n+ supported = \", \".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\n+ raise ValueError(f\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\")\n+ return path\n+\n+\n+def _finite_float(value: float, field_name: str) -> float:\n+ number = float(value)\n+ if not math.isfinite(number):\n+ raise ValueError(f\"{field_name} must be finite\")\n+ return number\n+\n+\n+def create_project(\n+ audio_path: str | Path,\n+ name: str | None = None,\n+ analysis_settings: dict[str, Any] | None = None,\n+) -> dict[str, Any]:\n+ audio = normalize_audio_path(audio_path)\n+ created_at = now_iso()\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\n+ if analysis_settings:\n+ settings.update(analysis_settings)\n+\n+ return {\n+ \"schema_version\": SCHEMA_VERSION,\n+ \"software\": {\"name\": \"WaveTone\", \"version\": SOFTWARE_VERSION, \"backend\": \"wavetone.exe\"},\n+ \"project\": {\"name\": name or audio.stem, \"created_at\": created_at, \"modified_at\": created_at},\n+ \"audio\": {\n+ \"path\": str(audio),\n+ \"filename\": audio.name,\n+ \"extension\": audio.suffix.lower(),\n+ \"size_bytes\": audio.stat().st_size,\n+ },\n+ \"analysis\": settings,\n+ \"tempo\": {\"bpm\": None, \"first_bar_time_seconds\": 0.0, \"meter\": \"4/4\"},\n+ \"labels\": [],\n+ \"notes\": [],\n+ \"wfd_path\": None,\n+ \"limitations\": [\n+ \"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\",\n+ \"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\",\n+ ],\n+ }\n+\n+\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\n+ project.setdefault(\"project\", {})[\"modified_at\"] = now_iso()\n+ return project\n+\n+\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\n+ path = Path(output_path).expanduser().resolve()\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ touch(project)\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return path\n+\n+\n+def load_project(project_path: str | Path) -> dict[str, Any]:\n+ path = Path(project_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Project file not found: {path}\")\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Project file must be a JSON object\")\n+ if data.get(\"schema_version\") != SCHEMA_VERSION:\n+ raise ValueError(f\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\")\n+ return data\n+\n+\n+def add_label(\n+ project: dict[str, Any],\n+ name: str,\n+ time_seconds: float,\n+ note: str | None = None,\n+) -> dict[str, Any]:\n+ time_value = _finite_float(time_seconds, \"Label time\")\n+ if time_value < 0:\n+ raise ValueError(\"Label time must be >= 0\")\n+ label: dict[str, Any] = {\"name\": name, \"time_seconds\": round(time_value, 6)}\n+ if note:\n+ label[\"note\"] = note\n+ project.setdefault(\"labels\", []).append(label)\n+ project[\"labels\"].sort(key=lambda item: item[\"time_seconds\"])\n+ return touch(project)\n+\n+\n+def set_tempo(\n+ project: dict[str, Any],\n+ bpm: float,\n+ first_bar_time_seconds: float = 0.0,\n+ meter: str = \"4/4\",\n+) -> dict[str, Any]:\n+ bpm_value = _finite_float(bpm, \"BPM\")\n+ first_bar_value = _finite_float(first_bar_time_seconds, \"First bar time\")\n+ if bpm_value <= 0:\n+ raise ValueError(\"BPM must be > 0\")\n+ if first_bar_value < 0:\n+ raise ValueError(\"First bar time must be >= 0\")\n+ project[\"tempo\"] = {\n+ \"bpm\": round(bpm_value, 6),\n+ \"first_bar_time_seconds\": round(first_bar_value, 6),\n+ \"meter\": meter,\n+ }\n+ return touch(project)\n+\n+\n+def update_analysis(project: dict[str, Any], **settings: Any) -> dict[str, Any]:\n+ analysis = project.setdefault(\"analysis\", deepcopy(DEFAULT_ANALYSIS_SETTINGS))\n+ for key, value in settings.items():\n+ if value is not None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{key} must be finite\")\n+ analysis[key] = value\n+ return touch(project)\n+\n+\n+def set_wfd_path(project: dict[str, Any], wfd_path: str | Path | None) -> dict[str, Any]:\n+ project[\"wfd_path\"] = None if wfd_path is None else str(Path(wfd_path).expanduser().resolve())\n+ return touch(project)\n+\n+\n+def project_summary(project: dict[str, Any]) -> dict[str, Any]:\n+ return {\n+ \"schema_version\": project.get(\"schema_version\"),\n+ \"name\": project.get(\"project\", {}).get(\"name\"),\n+ \"audio\": project.get(\"audio\"),\n+ \"tempo\": project.get(\"tempo\"),\n+ \"label_count\": len(project.get(\"labels\", [])),\n+ \"labels\": project.get(\"labels\", []),\n+ \"analysis\": project.get(\"analysis\"),\n+ \"wfd_path\": project.get(\"wfd_path\"),\n+ \"limitations\": project.get(\"limitations\", []),\n+ }\n"},{"comment":"**<sub><sub></sub></sub> Use a splitter that strips Windows REPL quotes**\n\nOn Windows this sets `posix=False`, and `shlex.split()` keeps the surrounding quote characters in each token; for example a REPL command like `project new \"C:\\Users\\me\\My Music\\song.wav\" -o \"C:\\Users\\me\\song.wt.json\"` passes paths that literally start/end with `\"` into Click, so `exists=True` path arguments fail. Because the harness is Windows-targeted and audio/project paths commonly contain spaces, quoted paths entered in the REPL should be unquoted before redispatch.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,358 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"wavetone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = shlex.split(line, posix=(os.name != \"nt\"))","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"`add_label()` converts `time_seconds` to `time_value` for validation/rounding but then compares the original `time_seconds` against `0`. If callers pass a non-float (e.g., a numeric string), `_finite_float()` will succeed but `time_seconds < 0` will raise `TypeError`. Compare against the validated `time_value` instead to keep behavior consistent with the conversion step.","path":"wavetone/agent-harness/cli_anything/wavetone/core/project.py","hunk":"@@ -0,0 +1,185 @@\n+\"\"\"Project manifest helpers for the WaveTone harness.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from copy import deepcopy\n+from datetime import datetime, timezone\n+from pathlib import Path\n+from typing import Any\n+\n+\n+SCHEMA_VERSION = \"wavetone-project/v1\"\n+SOFTWARE_VERSION = \"2.61\"\n+SUPPORTED_AUDIO_EXTENSIONS = {\n+ \".wav\",\n+ \".wave\",\n+ \".aif\",\n+ \".aiff\",\n+ \".mp3\",\n+ \".wma\",\n+ \".aac\",\n+ \".ogg\",\n+ \".oga\",\n+ \".flac\",\n+ \".wv\",\n+ \".ape\",\n+ \".alac\",\n+ \".tta\",\n+}\n+\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\n+ \"blocks_per_second\": 12,\n+ \"blocks_per_semitone\": 5,\n+ \"note_range\": \"C1-B7\",\n+ \"reference_frequency_hz\": 440.0,\n+ \"analyze_fundamental_frequency\": True,\n+ \"channel\": \"Stereo\",\n+ \"skip_analysis_dialog\": False,\n+}\n+\n+\n+def now_iso() -> str:\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\n+\n+\n+def normalize_audio_path(audio_path: str | Path) -> Path:\n+ path = Path(audio_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Audio file not found: {path}\")\n+ if not path.is_file():\n+ raise ValueError(f\"Audio path is not a file: {path}\")\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\n+ supported = \", \".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\n+ raise ValueError(f\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\")\n+ return path\n+\n+\n+def _finite_float(value: float, field_name: str) -> float:\n+ number = float(value)\n+ if not math.isfinite(number):\n+ raise ValueError(f\"{field_name} must be finite\")\n+ return number\n+\n+\n+def create_project(\n+ audio_path: str | Path,\n+ name: str | None = None,\n+ analysis_settings: dict[str, Any] | None = None,\n+) -> dict[str, Any]:\n+ audio = normalize_audio_path(audio_path)\n+ created_at = now_iso()\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\n+ if analysis_settings:\n+ settings.update(analysis_settings)\n+\n+ return {\n+ \"schema_version\": SCHEMA_VERSION,\n+ \"software\": {\"name\": \"WaveTone\", \"version\": SOFTWARE_VERSION, \"backend\": \"wavetone.exe\"},\n+ \"project\": {\"name\": name or audio.stem, \"created_at\": created_at, \"modified_at\": created_at},\n+ \"audio\": {\n+ \"path\": str(audio),\n+ \"filename\": audio.name,\n+ \"extension\": audio.suffix.lower(),\n+ \"size_bytes\": audio.stat().st_size,\n+ },\n+ \"analysis\": settings,\n+ \"tempo\": {\"bpm\": None, \"first_bar_time_seconds\": 0.0, \"meter\": \"4/4\"},\n+ \"labels\": [],\n+ \"notes\": [],\n+ \"wfd_path\": None,\n+ \"limitations\": [\n+ \"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\",\n+ \"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\",\n+ ],\n+ }\n+\n+\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\n+ project.setdefault(\"project\", {})[\"modified_at\"] = now_iso()\n+ return project\n+\n+\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\n+ path = Path(output_path).expanduser().resolve()\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ touch(project)\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return path\n+\n+\n+def load_project(project_path: str | Path) -> dict[str, Any]:\n+ path = Path(project_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Project file not found: {path}\")\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if data.get(\"schema_version\") != SCHEMA_VERSION:\n+ raise ValueError(f\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\")\n+ return data\n+\n+\n+def add_label(\n+ project: dict[str, Any],\n+ name: str,\n+ time_seconds: float,\n+ note: str | None = None,\n+) -> dict[str, Any]:\n+ time_value = _finite_float(time_seconds, \"Label time\")\n+ if time_seconds < 0:\n+ raise ValueError(\"Label time must be >= 0\")","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/project.py b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\nnew file mode 100644\nindex 000000000..7e06d8e07\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\n@@ -0,0 +1,187 @@\n+\"\"\"Project manifest helpers for the WaveTone harness.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from copy import deepcopy\n+from datetime import datetime, timezone\n+from pathlib import Path\n+from typing import Any\n+\n+\n+SCHEMA_VERSION = \"wavetone-project/v1\"\n+SOFTWARE_VERSION = \"2.61\"\n+SUPPORTED_AUDIO_EXTENSIONS = {\n+ \".wav\",\n+ \".wave\",\n+ \".aif\",\n+ \".aiff\",\n+ \".mp3\",\n+ \".wma\",\n+ \".aac\",\n+ \".ogg\",\n+ \".oga\",\n+ \".flac\",\n+ \".wv\",\n+ \".ape\",\n+ \".alac\",\n+ \".tta\",\n+}\n+\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\n+ \"blocks_per_second\": 12,\n+ \"blocks_per_semitone\": 5,\n+ \"note_range\": \"C1-B7\",\n+ \"reference_frequency_hz\": 440.0,\n+ \"analyze_fundamental_frequency\": True,\n+ \"channel\": \"Stereo\",\n+ \"skip_analysis_dialog\": False,\n+}\n+\n+\n+def now_iso() -> str:\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\n+\n+\n+def normalize_audio_path(audio_path: str | Path) -> Path:\n+ path = Path(audio_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Audio file not found: {path}\")\n+ if not path.is_file():\n+ raise ValueError(f\"Audio path is not a file: {path}\")\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\n+ supported = \", \".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\n+ raise ValueError(f\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\")\n+ return path\n+\n+\n+def _finite_float(value: float, field_name: str) -> float:\n+ number = float(value)\n+ if not math.isfinite(number):\n+ raise ValueError(f\"{field_name} must be finite\")\n+ return number\n+\n+\n+def create_project(\n+ audio_path: str | Path,\n+ name: str | None = None,\n+ analysis_settings: dict[str, Any] | None = None,\n+) -> dict[str, Any]:\n+ audio = normalize_audio_path(audio_path)\n+ created_at = now_iso()\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\n+ if analysis_settings:\n+ settings.update(analysis_settings)\n+\n+ return {\n+ \"schema_version\": SCHEMA_VERSION,\n+ \"software\": {\"name\": \"WaveTone\", \"version\": SOFTWARE_VERSION, \"backend\": \"wavetone.exe\"},\n+ \"project\": {\"name\": name or audio.stem, \"created_at\": created_at, \"modified_at\": created_at},\n+ \"audio\": {\n+ \"path\": str(audio),\n+ \"filename\": audio.name,\n+ \"extension\": audio.suffix.lower(),\n+ \"size_bytes\": audio.stat().st_size,\n+ },\n+ \"analysis\": settings,\n+ \"tempo\": {\"bpm\": None, \"first_bar_time_seconds\": 0.0, \"meter\": \"4/4\"},\n+ \"labels\": [],\n+ \"notes\": [],\n+ \"wfd_path\": None,\n+ \"limitations\": [\n+ \"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\",\n+ \"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\",\n+ ],\n+ }\n+\n+\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\n+ project.setdefault(\"project\", {})[\"modified_at\"] = now_iso()\n+ return project\n+\n+\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\n+ path = Path(output_path).expanduser().resolve()\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ touch(project)\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return path\n+\n+\n+def load_project(project_path: str | Path) -> dict[str, Any]:\n+ path = Path(project_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Project file not found: {path}\")\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Project file must be a JSON object\")\n+ if data.get(\"schema_version\") != SCHEMA_VERSION:\n+ raise ValueError(f\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\")\n+ return data\n+\n+\n+def add_label(\n+ project: dict[str, Any],\n+ name: str,\n+ time_seconds: float,\n+ note: str | None = None,\n+) -> dict[str, Any]:\n+ time_value = _finite_float(time_seconds, \"Label time\")\n+ if time_value < 0:\n+ raise ValueError(\"Label time must be >= 0\")\n+ label: dict[str, Any] = {\"name\": name, \"time_seconds\": round(time_value, 6)}\n+ if note:\n+ label[\"note\"] = note\n+ project.setdefault(\"labels\", []).append(label)\n+ project[\"labels\"].sort(key=lambda item: item[\"time_seconds\"])\n+ return touch(project)\n+\n+\n+def set_tempo(\n+ project: dict[str, Any],\n+ bpm: float,\n+ first_bar_time_seconds: float = 0.0,\n+ meter: str = \"4/4\",\n+) -> dict[str, Any]:\n+ bpm_value = _finite_float(bpm, \"BPM\")\n+ first_bar_value = _finite_float(first_bar_time_seconds, \"First bar time\")\n+ if bpm_value <= 0:\n+ raise ValueError(\"BPM must be > 0\")\n+ if first_bar_value < 0:\n+ raise ValueError(\"First bar time must be >= 0\")\n+ project[\"tempo\"] = {\n+ \"bpm\": round(bpm_value, 6),\n+ \"first_bar_time_seconds\": round(first_bar_value, 6),\n+ \"meter\": meter,\n+ }\n+ return touch(project)\n+\n+\n+def update_analysis(project: dict[str, Any], **settings: Any) -> dict[str, Any]:\n+ analysis = project.setdefault(\"analysis\", deepcopy(DEFAULT_ANALYSIS_SETTINGS))\n+ for key, value in settings.items():\n+ if value is not None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{key} must be finite\")\n+ analysis[key] = value\n+ return touch(project)\n+\n+\n+def set_wfd_path(project: dict[str, Any], wfd_path: str | Path | None) -> dict[str, Any]:\n+ project[\"wfd_path\"] = None if wfd_path is None else str(Path(wfd_path).expanduser().resolve())\n+ return touch(project)\n+\n+\n+def project_summary(project: dict[str, Any]) -> dict[str, Any]:\n+ return {\n+ \"schema_version\": project.get(\"schema_version\"),\n+ \"name\": project.get(\"project\", {}).get(\"name\"),\n+ \"audio\": project.get(\"audio\"),\n+ \"tempo\": project.get(\"tempo\"),\n+ \"label_count\": len(project.get(\"labels\", [])),\n+ \"labels\": project.get(\"labels\", []),\n+ \"analysis\": project.get(\"analysis\"),\n+ \"wfd_path\": project.get(\"wfd_path\"),\n+ \"limitations\": project.get(\"limitations\", []),\n+ }\n"},{"comment":"In `_probe_ffprobe()`, `sample_rate`, `bit_rate`, and `size_bytes` are normalized to ints, but `channels` is returned “as-is”. For consistency and to avoid type drift from ffprobe output variations, parse `channels` via the same `_safe_int()` helper.","path":"wavetone/agent-harness/cli_anything/wavetone/core/audio.py","hunk":"@@ -0,0 +1,112 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _safe_float(value: Any) -> float | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return float(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _safe_int(value: Any) -> int | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return int(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = _safe_float(fmt.get(\"duration\"))\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6) if duration is not None else None,\n+ \"sample_rate\": _safe_int(audio_stream.get(\"sample_rate\")),\n+ \"channels\": audio_stream.get(\"channels\"),\n+ \"bit_rate\": _safe_int(fmt.get(\"bit_rate\")),\n+ \"size_bytes\": _safe_int(fmt.get(\"size\")) or path.stat().st_size,\n+ \"probe_method\": \"ffprobe\",","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\nnew file mode 100644\nindex 000000000..f35f343f5\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\n@@ -0,0 +1,112 @@\n+\"\"\"Audio probing utilities for WaveTone projects.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shutil\n+import subprocess\n+import wave\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import normalize_audio_path\n+\n+\n+def _safe_float(value: Any) -> float | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return float(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _safe_int(value: Any) -> int | None:\n+ if value in (None, \"\", \"N/A\"):\n+ return None\n+ try:\n+ return int(value)\n+ except (TypeError, ValueError):\n+ return None\n+\n+\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\n+ with wave.open(str(path), \"rb\") as handle:\n+ frames = handle.getnframes()\n+ sample_rate = handle.getframerate()\n+ channels = handle.getnchannels()\n+ sample_width = handle.getsampwidth()\n+ duration = frames / sample_rate if sample_rate else 0.0\n+ return {\n+ \"path\": str(path),\n+ \"format\": \"wav\",\n+ \"codec\": \"pcm\",\n+ \"duration_seconds\": round(duration, 6),\n+ \"sample_rate\": sample_rate,\n+ \"channels\": channels,\n+ \"sample_width_bytes\": sample_width,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"python-wave\",\n+ }\n+\n+\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\n+ ffprobe = shutil.which(\"ffprobe\")\n+ if not ffprobe:\n+ raise RuntimeError(\"ffprobe not found\")\n+ result = subprocess.run(\n+ [\n+ ffprobe,\n+ \"-v\",\n+ \"error\",\n+ \"-show_entries\",\n+ \"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\",\n+ \"-of\",\n+ \"json\",\n+ str(path),\n+ ],\n+ capture_output=True,\n+ text=True,\n+ check=True,\n+ )\n+ data = json.loads(result.stdout)\n+ audio_stream = next(\n+ (stream for stream in data.get(\"streams\", []) if stream.get(\"codec_type\") == \"audio\"),\n+ {},\n+ )\n+ fmt = data.get(\"format\", {})\n+ duration = _safe_float(fmt.get(\"duration\"))\n+ return {\n+ \"path\": str(path),\n+ \"format\": fmt.get(\"format_name\"),\n+ \"codec\": audio_stream.get(\"codec_name\"),\n+ \"duration_seconds\": round(duration, 6) if duration is not None else None,\n+ \"sample_rate\": _safe_int(audio_stream.get(\"sample_rate\")),\n+ \"channels\": _safe_int(audio_stream.get(\"channels\")),\n+ \"bit_rate\": _safe_int(fmt.get(\"bit_rate\")),\n+ \"size_bytes\": _safe_int(fmt.get(\"size\")) or path.stat().st_size,\n+ \"probe_method\": \"ffprobe\",\n+ }\n+\n+\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\n+ path = normalize_audio_path(audio_path)\n+ if path.suffix.lower() in {\".wav\", \".wave\"}:\n+ try:\n+ return _probe_wav_stdlib(path)\n+ except (wave.Error, EOFError):\n+ pass\n+ try:\n+ return _probe_ffprobe(path)\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\n+ return {\n+ \"path\": str(path),\n+ \"format\": path.suffix.lower().lstrip(\".\") or None,\n+ \"codec\": None,\n+ \"duration_seconds\": None,\n+ \"sample_rate\": None,\n+ \"channels\": None,\n+ \"size_bytes\": path.stat().st_size,\n+ \"probe_method\": \"stat\",\n+ \"warning\": \"Install ffprobe for detailed metadata on this format.\",\n+ }\n"},{"comment":"`long_description` reads `cli_anything/wavetone/README.md`, but this file may not be included in the built sdist/wheel unless it’s explicitly included (e.g., via `MANIFEST.in` or `package_data`). Consider ensuring the README is packaged, otherwise published metadata may end up with an empty long description even when the source repo has documentation.","path":"wavetone/agent-harness/setup.py","hunk":"@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\nnew file mode 100644\nindex 000000000..4821f34d0\n--- /dev/null\n+++ b/wavetone/agent-harness/setup.py\n@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ packages=find_namespace_packages(\n+ include=[\"cli_anything.*\"],\n+ exclude=[\"cli_anything.*.tests\", \"cli_anything.*.tests.*\"],\n+ ),\n+ classifiers=[\n+ \"Development Status :: 4 - Beta\",\n+ \"Intended Audience :: Developers\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Analysis\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Editors\",\n+ \"License :: OSI Approved :: MIT License\",\n+ \"Programming Language :: Python :: 3\",\n+ \"Programming Language :: Python :: 3.10\",\n+ \"Programming Language :: Python :: 3.11\",\n+ \"Programming Language :: Python :: 3.12\",\n+ \"Operating System :: Microsoft :: Windows\",\n+ ],\n+ python_requires=\">=3.10\",\n+ install_requires=[\"click>=8.0.0\", \"prompt-toolkit>=3.0.0\"],\n+ extras_require={\"dev\": [\"pytest>=7.0.0\"]},\n+ entry_points={\n+ \"console_scripts\": [\n+ \"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\",\n+ ],\n+ },\n+ package_data={\"cli_anything.wavetone\": [\"README.md\", \"skills/SKILL.md\", \"skills/*.md\"]},\n+ include_package_data=True,\n+ zip_safe=False,\n+)\n"},{"comment":"`long_description` reads `cli_anything/wavetone/README.md`, but this file may not be included in the built sdist/wheel unless it’s explicitly included (e.g., via `MANIFEST.in` or `package_data`). Consider ensuring the README is packaged, otherwise published metadata may end up with an empty long description even when the source repo has documentation.","path":"wavetone/agent-harness/setup.py","hunk":"@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\nnew file mode 100644\nindex 000000000..4821f34d0\n--- /dev/null\n+++ b/wavetone/agent-harness/setup.py\n@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Setup for cli-anything-wavetone.\"\"\"\n+\n+from pathlib import Path\n+\n+from setuptools import find_namespace_packages, setup\n+\n+\n+readme = Path(__file__).parent / \"cli_anything\" / \"wavetone\" / \"README.md\"\n+\n+setup(\n+ name=\"cli-anything-wavetone\",\n+ version=\"1.0.0\",\n+ author=\"cli-anything contributors\",\n+ description=(\n+ \"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \"\n+ \"analysis manifests and launches the real WaveTone Windows executable.\"\n+ ),\n+ long_description=readme.read_text(encoding=\"utf-8\") if readme.exists() else \"\",\n+ long_description_content_type=\"text/markdown\",\n+ url=\"https://github.com/HKUDS/CLI-Anything\",\n+ packages=find_namespace_packages(\n+ include=[\"cli_anything.*\"],\n+ exclude=[\"cli_anything.*.tests\", \"cli_anything.*.tests.*\"],\n+ ),\n+ classifiers=[\n+ \"Development Status :: 4 - Beta\",\n+ \"Intended Audience :: Developers\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Analysis\",\n+ \"Topic :: Multimedia :: Sound/Audio :: Editors\",\n+ \"License :: OSI Approved :: MIT License\",\n+ \"Programming Language :: Python :: 3\",\n+ \"Programming Language :: Python :: 3.10\",\n+ \"Programming Language :: Python :: 3.11\",\n+ \"Programming Language :: Python :: 3.12\",\n+ \"Operating System :: Microsoft :: Windows\",\n+ ],\n+ python_requires=\">=3.10\",\n+ install_requires=[\"click>=8.0.0\", \"prompt-toolkit>=3.0.0\"],\n+ extras_require={\"dev\": [\"pytest>=7.0.0\"]},\n+ entry_points={\n+ \"console_scripts\": [\n+ \"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\",\n+ ],\n+ },\n+ package_data={\"cli_anything.wavetone\": [\"README.md\", \"skills/SKILL.md\", \"skills/*.md\"]},\n+ include_package_data=True,\n+ zip_safe=False,\n+)\n"},{"comment":"The same SKILL content appears to be duplicated both here and in `wavetone/agent-harness/cli_anything/wavetone/skills/SKILL.md`. Keeping two sources of truth increases the chance they diverge; consider generating one from the other (build step) or referencing a single canonical copy if the repo structure allows it.","path":"skills/cli-anything-wavetone/SKILL.md","hunk":"@@ -0,0 +1,53 @@\n+---\n+name: \"cli-anything-wavetone\"\n+description: \"Control WaveTone 2.61 workflows through a JSON manifest and launch the real Windows WaveTone executable.\"\n+---","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/skills/cli-anything-wavetone/SKILL.md b/skills/cli-anything-wavetone/SKILL.md\nnew file mode 100644\nindex 000000000..a565109ed\n--- /dev/null\n+++ b/skills/cli-anything-wavetone/SKILL.md\n@@ -0,0 +1,53 @@\n+---\n+name: \"cli-anything-wavetone\"\n+description: \"Control WaveTone 2.61 workflows through a JSON manifest and launch the real Windows WaveTone executable.\"\n+---\n+\n+# cli-anything-wavetone\n+\n+Use this skill when an agent needs to prepare, inspect, and launch WaveTone 2.61\n+audio transcription workflows.\n+\n+## Requirements\n+\n+- Windows host.\n+- WaveTone 2.61 extracted locally.\n+- Set `WAVETONE_EXE` to `wavetone.exe` or `WAVETONE_HOME` to the extracted\n+ WaveTone directory when the default portable path is not used.\n+\n+## Core Commands\n+\n+All commands support the top-level `--json` flag.\n+\n+```bash\n+cli-anything-wavetone --json wavetone doctor\n+cli-anything-wavetone --json project new input.wav -o project.wt.json\n+cli-anything-wavetone --project project.wt.json --json audio probe\n+cli-anything-wavetone --project project.wt.json --json project set-tempo --bpm 120 --meter 4/4\n+cli-anything-wavetone --project project.wt.json --json project add-label chorus --time 64.0\n+cli-anything-wavetone --project project.wt.json --json wavetone launch\n+```\n+\n+## Command Groups\n+\n+- `project`: create manifests, set tempo, add labels, update intended analysis\n+ settings, and attach a WFD saved from WaveTone.\n+- `audio`: probe audio metadata before opening it in WaveTone.\n+- `wavetone`: run `doctor`, list supported formats, or launch the real GUI.\n+- `session`: record lightweight event logs for multi-step agent workflows.\n+- `defaults`: show default analysis settings.\n+\n+## Agent Guidance\n+\n+The JSON project manifest is not a WaveTone WFD file. It is an agent-facing plan\n+for the source audio, intended analysis settings, labels, and tempo metadata.\n+Use WaveTone itself to perform analysis and save WFD/MIDI/text/WAVE outputs.\n+\n+When running in automated checks, use:\n+\n+```bash\n+cli-anything-wavetone --json wavetone launch input.wav --wait 1 --terminate\n+```\n+\n+This confirms that the real backend can be started without leaving a persistent\n+GUI process behind.\n"},{"comment":"**<sub><sub></sub></sub> Reject non-object project JSON**\n\nWhen the project path points to a syntactically valid JSON file whose top-level value is not an object, such as `[]`, `json.loads` succeeds but this `.get` call raises `AttributeError`. The CLI handlers only convert `OSError`/`ValueError` into Click errors, so `project info` and project mutation commands exit with a traceback instead of a clean error/JSON failure; validate `isinstance(data, dict)` and raise `ValueError` before using `.get`.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/core/project.py","hunk":"@@ -0,0 +1,185 @@\n+\"\"\"Project manifest helpers for the WaveTone harness.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from copy import deepcopy\n+from datetime import datetime, timezone\n+from pathlib import Path\n+from typing import Any\n+\n+\n+SCHEMA_VERSION = \"wavetone-project/v1\"\n+SOFTWARE_VERSION = \"2.61\"\n+SUPPORTED_AUDIO_EXTENSIONS = {\n+ \".wav\",\n+ \".wave\",\n+ \".aif\",\n+ \".aiff\",\n+ \".mp3\",\n+ \".wma\",\n+ \".aac\",\n+ \".ogg\",\n+ \".oga\",\n+ \".flac\",\n+ \".wv\",\n+ \".ape\",\n+ \".alac\",\n+ \".tta\",\n+}\n+\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\n+ \"blocks_per_second\": 12,\n+ \"blocks_per_semitone\": 5,\n+ \"note_range\": \"C1-B7\",\n+ \"reference_frequency_hz\": 440.0,\n+ \"analyze_fundamental_frequency\": True,\n+ \"channel\": \"Stereo\",\n+ \"skip_analysis_dialog\": False,\n+}\n+\n+\n+def now_iso() -> str:\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\n+\n+\n+def normalize_audio_path(audio_path: str | Path) -> Path:\n+ path = Path(audio_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Audio file not found: {path}\")\n+ if not path.is_file():\n+ raise ValueError(f\"Audio path is not a file: {path}\")\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\n+ supported = \", \".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\n+ raise ValueError(f\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\")\n+ return path\n+\n+\n+def _finite_float(value: float, field_name: str) -> float:\n+ number = float(value)\n+ if not math.isfinite(number):\n+ raise ValueError(f\"{field_name} must be finite\")\n+ return number\n+\n+\n+def create_project(\n+ audio_path: str | Path,\n+ name: str | None = None,\n+ analysis_settings: dict[str, Any] | None = None,\n+) -> dict[str, Any]:\n+ audio = normalize_audio_path(audio_path)\n+ created_at = now_iso()\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\n+ if analysis_settings:\n+ settings.update(analysis_settings)\n+\n+ return {\n+ \"schema_version\": SCHEMA_VERSION,\n+ \"software\": {\"name\": \"WaveTone\", \"version\": SOFTWARE_VERSION, \"backend\": \"wavetone.exe\"},\n+ \"project\": {\"name\": name or audio.stem, \"created_at\": created_at, \"modified_at\": created_at},\n+ \"audio\": {\n+ \"path\": str(audio),\n+ \"filename\": audio.name,\n+ \"extension\": audio.suffix.lower(),\n+ \"size_bytes\": audio.stat().st_size,\n+ },\n+ \"analysis\": settings,\n+ \"tempo\": {\"bpm\": None, \"first_bar_time_seconds\": 0.0, \"meter\": \"4/4\"},\n+ \"labels\": [],\n+ \"notes\": [],\n+ \"wfd_path\": None,\n+ \"limitations\": [\n+ \"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\",\n+ \"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\",\n+ ],\n+ }\n+\n+\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\n+ project.setdefault(\"project\", {})[\"modified_at\"] = now_iso()\n+ return project\n+\n+\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\n+ path = Path(output_path).expanduser().resolve()\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ touch(project)\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return path\n+\n+\n+def load_project(project_path: str | Path) -> dict[str, Any]:\n+ path = Path(project_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Project file not found: {path}\")\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if data.get(\"schema_version\") != SCHEMA_VERSION:","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/project.py b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\nnew file mode 100644\nindex 000000000..7e06d8e07\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\n@@ -0,0 +1,187 @@\n+\"\"\"Project manifest helpers for the WaveTone harness.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from copy import deepcopy\n+from datetime import datetime, timezone\n+from pathlib import Path\n+from typing import Any\n+\n+\n+SCHEMA_VERSION = \"wavetone-project/v1\"\n+SOFTWARE_VERSION = \"2.61\"\n+SUPPORTED_AUDIO_EXTENSIONS = {\n+ \".wav\",\n+ \".wave\",\n+ \".aif\",\n+ \".aiff\",\n+ \".mp3\",\n+ \".wma\",\n+ \".aac\",\n+ \".ogg\",\n+ \".oga\",\n+ \".flac\",\n+ \".wv\",\n+ \".ape\",\n+ \".alac\",\n+ \".tta\",\n+}\n+\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\n+ \"blocks_per_second\": 12,\n+ \"blocks_per_semitone\": 5,\n+ \"note_range\": \"C1-B7\",\n+ \"reference_frequency_hz\": 440.0,\n+ \"analyze_fundamental_frequency\": True,\n+ \"channel\": \"Stereo\",\n+ \"skip_analysis_dialog\": False,\n+}\n+\n+\n+def now_iso() -> str:\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\n+\n+\n+def normalize_audio_path(audio_path: str | Path) -> Path:\n+ path = Path(audio_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Audio file not found: {path}\")\n+ if not path.is_file():\n+ raise ValueError(f\"Audio path is not a file: {path}\")\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\n+ supported = \", \".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\n+ raise ValueError(f\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\")\n+ return path\n+\n+\n+def _finite_float(value: float, field_name: str) -> float:\n+ number = float(value)\n+ if not math.isfinite(number):\n+ raise ValueError(f\"{field_name} must be finite\")\n+ return number\n+\n+\n+def create_project(\n+ audio_path: str | Path,\n+ name: str | None = None,\n+ analysis_settings: dict[str, Any] | None = None,\n+) -> dict[str, Any]:\n+ audio = normalize_audio_path(audio_path)\n+ created_at = now_iso()\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\n+ if analysis_settings:\n+ settings.update(analysis_settings)\n+\n+ return {\n+ \"schema_version\": SCHEMA_VERSION,\n+ \"software\": {\"name\": \"WaveTone\", \"version\": SOFTWARE_VERSION, \"backend\": \"wavetone.exe\"},\n+ \"project\": {\"name\": name or audio.stem, \"created_at\": created_at, \"modified_at\": created_at},\n+ \"audio\": {\n+ \"path\": str(audio),\n+ \"filename\": audio.name,\n+ \"extension\": audio.suffix.lower(),\n+ \"size_bytes\": audio.stat().st_size,\n+ },\n+ \"analysis\": settings,\n+ \"tempo\": {\"bpm\": None, \"first_bar_time_seconds\": 0.0, \"meter\": \"4/4\"},\n+ \"labels\": [],\n+ \"notes\": [],\n+ \"wfd_path\": None,\n+ \"limitations\": [\n+ \"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\",\n+ \"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\",\n+ ],\n+ }\n+\n+\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\n+ project.setdefault(\"project\", {})[\"modified_at\"] = now_iso()\n+ return project\n+\n+\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\n+ path = Path(output_path).expanduser().resolve()\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ touch(project)\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return path\n+\n+\n+def load_project(project_path: str | Path) -> dict[str, Any]:\n+ path = Path(project_path).expanduser().resolve()\n+ if not path.exists():\n+ raise FileNotFoundError(f\"Project file not found: {path}\")\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Project file must be a JSON object\")\n+ if data.get(\"schema_version\") != SCHEMA_VERSION:\n+ raise ValueError(f\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\")\n+ return data\n+\n+\n+def add_label(\n+ project: dict[str, Any],\n+ name: str,\n+ time_seconds: float,\n+ note: str | None = None,\n+) -> dict[str, Any]:\n+ time_value = _finite_float(time_seconds, \"Label time\")\n+ if time_value < 0:\n+ raise ValueError(\"Label time must be >= 0\")\n+ label: dict[str, Any] = {\"name\": name, \"time_seconds\": round(time_value, 6)}\n+ if note:\n+ label[\"note\"] = note\n+ project.setdefault(\"labels\", []).append(label)\n+ project[\"labels\"].sort(key=lambda item: item[\"time_seconds\"])\n+ return touch(project)\n+\n+\n+def set_tempo(\n+ project: dict[str, Any],\n+ bpm: float,\n+ first_bar_time_seconds: float = 0.0,\n+ meter: str = \"4/4\",\n+) -> dict[str, Any]:\n+ bpm_value = _finite_float(bpm, \"BPM\")\n+ first_bar_value = _finite_float(first_bar_time_seconds, \"First bar time\")\n+ if bpm_value <= 0:\n+ raise ValueError(\"BPM must be > 0\")\n+ if first_bar_value < 0:\n+ raise ValueError(\"First bar time must be >= 0\")\n+ project[\"tempo\"] = {\n+ \"bpm\": round(bpm_value, 6),\n+ \"first_bar_time_seconds\": round(first_bar_value, 6),\n+ \"meter\": meter,\n+ }\n+ return touch(project)\n+\n+\n+def update_analysis(project: dict[str, Any], **settings: Any) -> dict[str, Any]:\n+ analysis = project.setdefault(\"analysis\", deepcopy(DEFAULT_ANALYSIS_SETTINGS))\n+ for key, value in settings.items():\n+ if value is not None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{key} must be finite\")\n+ analysis[key] = value\n+ return touch(project)\n+\n+\n+def set_wfd_path(project: dict[str, Any], wfd_path: str | Path | None) -> dict[str, Any]:\n+ project[\"wfd_path\"] = None if wfd_path is None else str(Path(wfd_path).expanduser().resolve())\n+ return touch(project)\n+\n+\n+def project_summary(project: dict[str, Any]) -> dict[str, Any]:\n+ return {\n+ \"schema_version\": project.get(\"schema_version\"),\n+ \"name\": project.get(\"project\", {}).get(\"name\"),\n+ \"audio\": project.get(\"audio\"),\n+ \"tempo\": project.get(\"tempo\"),\n+ \"label_count\": len(project.get(\"labels\", [])),\n+ \"labels\": project.get(\"labels\", []),\n+ \"analysis\": project.get(\"analysis\"),\n+ \"wfd_path\": project.get(\"wfd_path\"),\n+ \"limitations\": project.get(\"limitations\", []),\n+ }\n"},{"comment":"**<sub><sub></sub></sub> Reject non-finite session payload values**\n\nWhen `session record --payload` contains `NaN` or `Infinity`, Python's JSON parser accepts those constants and this write uses the default `allow_nan=True`, so the session log (and the `--json` response) contains non-standard JSON tokens that strict consumers cannot parse. Reject these constants during payload parsing or serialize with `allow_nan=False` so the command fails before corrupting the session file.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/core/session.py","hunk":"@@ -0,0 +1,48 @@\n+\"\"\"Small session event log for WaveTone CLI runs.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import now_iso\n+\n+\n+def _new_session() -> dict[str, Any]:\n+ return {\"schema_version\": \"wavetone-session/v1\", \"events\": []}\n+\n+\n+def _load_session_data(path: Path) -> dict[str, Any]:\n+ if not path.exists():\n+ return _new_session()\n+\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Session file must be a JSON object\")\n+\n+ events = data.get(\"events\")\n+ if events is None:\n+ data[\"events\"] = []\n+ elif not isinstance(events, list):\n+ raise ValueError(\"Session file field 'events' must be a list\")\n+\n+ return data\n+\n+\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\n+ path = Path(session_path).expanduser().resolve()\n+ data = _load_session_data(path)\n+ record = {\"time\": now_iso(), \"event\": event, \"payload\": payload}\n+ data[\"events\"].append(record)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/session.py b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\nnew file mode 100644\nindex 000000000..d9f2c7f26\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\n@@ -0,0 +1,61 @@\n+\"\"\"Small session event log for WaveTone CLI runs.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import math\n+from pathlib import Path\n+from typing import Any\n+\n+from .project import now_iso\n+\n+\n+def _new_session() -> dict[str, Any]:\n+ return {\"schema_version\": \"wavetone-session/v1\", \"events\": []}\n+\n+\n+def _assert_json_safe(value: Any, path: str = \"payload\") -> None:\n+ if isinstance(value, float) and not math.isfinite(value):\n+ raise ValueError(f\"{path} must contain only finite numbers\")\n+ if isinstance(value, dict):\n+ for key, item in value.items():\n+ _assert_json_safe(item, f\"{path}.{key}\")\n+ elif isinstance(value, list):\n+ for idx, item in enumerate(value):\n+ _assert_json_safe(item, f\"{path}[{idx}]\")\n+\n+\n+def _load_session_data(path: Path) -> dict[str, Any]:\n+ if not path.exists():\n+ return _new_session()\n+\n+ data = json.loads(path.read_text(encoding=\"utf-8\"))\n+ if not isinstance(data, dict):\n+ raise ValueError(\"Session file must be a JSON object\")\n+\n+ events = data.get(\"events\")\n+ if events is None:\n+ data[\"events\"] = []\n+ elif not isinstance(events, list):\n+ raise ValueError(\"Session file field 'events' must be a list\")\n+\n+ return data\n+\n+\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\n+ path = Path(session_path).expanduser().resolve()\n+ data = _load_session_data(path)\n+ _assert_json_safe(payload)\n+ record = {\"time\": now_iso(), \"event\": event, \"payload\": payload}\n+ data[\"events\"].append(record)\n+ path.parent.mkdir(parents=True, exist_ok=True)\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\n+ return record\n+\n+\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\n+ path = Path(session_path).expanduser().resolve()\n+ if not path.exists():\n+ return []\n+ data = _load_session_data(path)\n+ return list(data[\"events\"])\n"},{"comment":"**<sub><sub></sub></sub> Convert non-Windows launch failures to Click errors**\n\nWhen `cli-anything-wavetone --json wavetone launch` is run on a non-Windows host, `wavetone_backend.launch_wavetone()` raises `RuntimeError(\"WaveTone launch requires Windows\")`, but this handler only converts `OSError` and `ValueError` into `ClickException`. The result is an uncaught traceback instead of the CLI's normal clean error path/JSON-safe behavior, which affects Linux/macOS environments that can still run the CLI-only commands and skipped backend tests.\n\nUseful? React with 👍 / 👎.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,367 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"wavetone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental/--no-fundamental\", default=None)\n+@click.option(\"--skip-dialog/--show-dialog\", default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, ValueError) as exc:","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"`--fundamental/--no-fundamental` and `--skip-dialog/--show-dialog` are intended to be tri-state (so omitted flags don’t overwrite existing manifest settings), but Click boolean flag pairs typically coerce a `None` default into `False` for flags. This causes `project analysis` to always write `False` for these settings even when the user doesn’t pass either flag. Use two options with the same destination and `flag_value` (defaulting to `None`) to preserve tri-state behavior (e.g., `--fundamental` sets True, `--no-fundamental` sets False, else None), and the same pattern for `skip_dialog`.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,367 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"wavetone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental/--no-fundamental\", default=None)\n+@click.option(\"--skip-dialog/--show-dialog\", default=None)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"`doctor()` marks required decoder artifacts as OK if a path merely exists; this will incorrectly pass when a required file path is a directory. Use `path.is_file()` (and optionally guard the loop when `data_dir` is not a directory) so `ready` reflects a valid WaveTone installation.","path":"wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py","hunk":"@@ -0,0 +1,163 @@\n+\"\"\"Backend wrapper for the real WaveTone 2.61 executable.\"\"\"\n+\n+from __future__ import annotations\n+\n+import os\n+import platform\n+import subprocess\n+import time\n+from pathlib import Path\n+from typing import Any\n+\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\n+\n+\n+REQUIRED_DATA_FILES = [\n+ \"awlib.dll\",\n+ \"bass.dll\",\n+ \"bassflac.dll\",\n+ \"basswma.dll\",\n+ \"basswv.dll\",\n+ \"bass_aac.dll\",\n+ \"bass_alac.dll\",\n+ \"bass_ape.dll\",\n+ \"bass_tta.dll\",\n+ \"asdecoder.exe\",\n+]\n+\n+\n+def default_candidates() -> list[Path]:\n+ candidates: list[Path] = []\n+ env_exe = os.environ.get(\"WAVETONE_EXE\")\n+ if env_exe:\n+ candidates.append(Path(env_exe))\n+ env_home = os.environ.get(\"WAVETONE_HOME\")\n+ if env_home:\n+ candidates.append(Path(env_home) / \"wavetone.exe\")\n+ candidates.append(Path(env_home) / \"WaveTone.exe\")\n+ home = Path.home()\n+ candidates.extend(\n+ [\n+ home / \"Desktop\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ home / \"Downloads\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ Path(\"C:/Program Files/WaveTone/wavetone.exe\"),\n+ Path(\"C:/Program Files (x86)/WaveTone/wavetone.exe\"),\n+ ]\n+ )\n+ return candidates\n+\n+\n+def find_wavetone(executable: str | Path | None = None) -> Path:\n+ candidates = [Path(executable)] if executable else default_candidates()\n+ checked: list[str] = []\n+ for candidate in candidates:\n+ path = candidate.expanduser()\n+ checked.append(str(path))\n+ if path.exists() and path.is_file():\n+ return path.resolve()\n+ raise FileNotFoundError(\n+ \"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \"\n+ \"WAVETONE_HOME to the extracted WaveTone directory. Checked: \"\n+ + \"; \".join(checked)\n+ )\n+\n+\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\n+ checks: list[dict[str, Any]] = []\n+ try:\n+ exe = find_wavetone(executable)\n+ root = exe.parent\n+ checks.append({\"name\": \"wavetone executable\", \"ok\": True, \"path\": str(exe)})\n+ except FileNotFoundError as exc:\n+ return {\n+ \"ready\": False,\n+ \"platform\": platform.system(),\n+ \"checks\": [{\"name\": \"wavetone executable\", \"ok\": False, \"error\": str(exc)}],\n+ }\n+\n+ data_dir = root / \"data\"\n+ checks.append({\"name\": \"data directory\", \"ok\": data_dir.is_dir(), \"path\": str(data_dir)})\n+ for filename in REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ checks.append({\"name\": f\"data/{filename}\", \"ok\": path.exists(), \"path\": str(path)})","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\nnew file mode 100644\nindex 000000000..81d3d35ec\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\n@@ -0,0 +1,163 @@\n+\"\"\"Backend wrapper for the real WaveTone 2.61 executable.\"\"\"\n+\n+from __future__ import annotations\n+\n+import os\n+import platform\n+import subprocess\n+import time\n+from pathlib import Path\n+from typing import Any\n+\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\n+\n+\n+REQUIRED_DATA_FILES = [\n+ \"awlib.dll\",\n+ \"bass.dll\",\n+ \"bassflac.dll\",\n+ \"basswma.dll\",\n+ \"basswv.dll\",\n+ \"bass_aac.dll\",\n+ \"bass_alac.dll\",\n+ \"bass_ape.dll\",\n+ \"bass_tta.dll\",\n+ \"asdecoder.exe\",\n+]\n+\n+\n+def default_candidates() -> list[Path]:\n+ candidates: list[Path] = []\n+ env_exe = os.environ.get(\"WAVETONE_EXE\")\n+ if env_exe:\n+ candidates.append(Path(env_exe))\n+ env_home = os.environ.get(\"WAVETONE_HOME\")\n+ if env_home:\n+ candidates.append(Path(env_home) / \"wavetone.exe\")\n+ candidates.append(Path(env_home) / \"WaveTone.exe\")\n+ home = Path.home()\n+ candidates.extend(\n+ [\n+ home / \"Desktop\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ home / \"Downloads\" / \"wavetone2.6.1\" / \"wavetone.exe\",\n+ Path(\"C:/Program Files/WaveTone/wavetone.exe\"),\n+ Path(\"C:/Program Files (x86)/WaveTone/wavetone.exe\"),\n+ ]\n+ )\n+ return candidates\n+\n+\n+def find_wavetone(executable: str | Path | None = None) -> Path:\n+ candidates = [Path(executable)] if executable else default_candidates()\n+ checked: list[str] = []\n+ for candidate in candidates:\n+ path = candidate.expanduser()\n+ checked.append(str(path))\n+ if path.exists() and path.is_file():\n+ return path.resolve()\n+ raise FileNotFoundError(\n+ \"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \"\n+ \"WAVETONE_HOME to the extracted WaveTone directory. Checked: \"\n+ + \"; \".join(checked)\n+ )\n+\n+\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\n+ checks: list[dict[str, Any]] = []\n+ try:\n+ exe = find_wavetone(executable)\n+ root = exe.parent\n+ checks.append({\"name\": \"wavetone executable\", \"ok\": True, \"path\": str(exe)})\n+ except FileNotFoundError as exc:\n+ return {\n+ \"ready\": False,\n+ \"platform\": platform.system(),\n+ \"checks\": [{\"name\": \"wavetone executable\", \"ok\": False, \"error\": str(exc)}],\n+ }\n+\n+ data_dir = root / \"data\"\n+ checks.append({\"name\": \"data directory\", \"ok\": data_dir.is_dir(), \"path\": str(data_dir)})\n+ for filename in REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ checks.append({\"name\": f\"data/{filename}\", \"ok\": path.is_file(), \"path\": str(path)})\n+ help_dir = root / \"wthelp\"\n+ checks.append({\"name\": \"help directory\", \"ok\": help_dir.is_dir(), \"path\": str(help_dir)})\n+ checks.append(\n+ {\n+ \"name\": \"windows host\",\n+ \"ok\": platform.system().lower() == \"windows\",\n+ \"platform\": platform.platform(),\n+ }\n+ )\n+ return {\n+ \"ready\": all(check[\"ok\"] for check in checks),\n+ \"platform\": platform.system(),\n+ \"root\": str(root),\n+ \"checks\": checks,\n+ }\n+\n+\n+def launch_wavetone(\n+ audio_path: str | Path | None = None,\n+ executable: str | Path | None = None,\n+ wait_seconds: float = 0.0,\n+ terminate: bool = False,\n+) -> dict[str, Any]:\n+ if platform.system().lower() != \"windows\":\n+ raise RuntimeError(\"WaveTone launch requires Windows\")\n+\n+ exe = find_wavetone(executable)\n+ args = [str(exe)]\n+ audio: Path | None = None\n+ if audio_path:\n+ audio = normalize_audio_path(audio_path)\n+ args.append(str(audio))\n+\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\n+ if wait_seconds > 0:\n+ time.sleep(wait_seconds)\n+ polled = process.poll()\n+ running_after_wait = polled is None\n+ exit_code = polled\n+ terminated = False\n+ if terminate and running_after_wait:\n+ process.terminate()\n+ try:\n+ process.wait(timeout=3)\n+ except subprocess.TimeoutExpired:\n+ process.kill()\n+ process.wait(timeout=3)\n+ terminated = True\n+ exit_code = process.returncode\n+\n+ return {\n+ \"backend\": \"wavetone.exe\",\n+ \"executable\": str(exe),\n+ \"cwd\": str(exe.parent),\n+ \"pid\": process.pid,\n+ \"args\": args,\n+ \"audio_path\": str(audio) if audio else None,\n+ \"running_after_wait\": running_after_wait,\n+ \"terminated\": terminated,\n+ \"exit_code\": exit_code,\n+ \"note\": \"WaveTone analysis and export dialogs are GUI driven in version 2.61.\",\n+ }\n+\n+\n+def supported_formats() -> dict[str, Any]:\n+ return {\n+ \"extensions\": sorted(SUPPORTED_AUDIO_EXTENSIONS),\n+ \"from_readme\": [\n+ \"WAVE\",\n+ \"AIFF\",\n+ \"MP3\",\n+ \"WMA\",\n+ \"AAC\",\n+ \"Vorbis\",\n+ \"FLAC\",\n+ \"WavPack\",\n+ \"Monkey's Audio\",\n+ \"ALAC\",\n+ \"TTA\",\n+ ],\n+ }\n"},{"comment":"The E2E tests will silently prefer any `cli-anything-wavetone` found in `PATH`, which can make the suite run against an older/foreign installed version instead of the code under test. Consider defaulting to `python -m cli_anything.wavetone.wavetone_cli` and only using the installed entry point when explicitly requested (e.g., `CLI_ANYTHING_FORCE_INSTALLED=1`).","path":"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py","hunk":"@@ -0,0 +1,144 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str) -> list[str]:\n+ \"\"\"Resolve installed CLI command; fall back to python -m for development.\"\"\"\n+ force = os.environ.get(\"CLI_ANYTHING_FORCE_INSTALLED\", \"\").strip() == \"1\"\n+ path = shutil.which(name)\n+ if path:\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+ if force:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ print(f\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2ceb45661\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\n@@ -0,0 +1,153 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\n+ \"\"\"Run the in-tree module by default; installed entry points are opt-in.\"\"\"\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ if not force_installed:\n+ print(f\"[_resolve_cli] Using source module: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+ path = shutil.which(name)\n+ if not path:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+\n+\n+def _env_flag_enabled(name: str) -> bool:\n+ return os.environ.get(name, \"\").strip().lower() in {\"1\", \"true\", \"yes\", \"on\"}\n+\n+\n+def _real_backend_ready() -> tuple[bool, str]:\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\n+ return False, f\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+ if sys.platform != \"win32\":\n+ return False, \"WaveTone real-backend tests require Windows\"\n+ if not (os.environ.get(\"WAVETONE_EXE\") or os.environ.get(\"WAVETONE_HOME\")):\n+ return False, \"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+\n+ status = wavetone_backend.doctor()\n+ if status.get(\"ready\"):\n+ return True, \"\"\n+\n+ failed_checks = [check[\"name\"] for check in status.get(\"checks\", []) if not check.get(\"ok\")]\n+ reason = \", \".join(failed_checks) if failed_checks else \"WaveTone backend is not ready\"\n+ return False, f\"WaveTone real backend unavailable: {reason}\"\n+\n+\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\n+\n+\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\n+ monkeypatch.delenv(\"WAVETONE_EXE\", raising=False)\n+ monkeypatch.delenv(\"WAVETONE_HOME\", raising=False)\n+\n+ ready, reason = _real_backend_ready()\n+\n+ assert ready is False\n+ assert REAL_BACKEND_ENV in reason\n+\n+\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setenv(\"CLI_ANYTHING_FORCE_INSTALLED\", \"1\")\n+ monkeypatch.setattr(shutil, \"which\", lambda name: pytest.fail(\"default resolver should not inspect PATH\"))\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\") == [sys.executable, \"-m\", \"cli_anything.wavetone.wavetone_cli\"]\n+\n+\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setattr(shutil, \"which\", lambda name: \"C:/installed/cli-anything-wavetone.exe\")\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\", force_installed=True) == [\"C:/installed/cli-anything-wavetone.exe\"]\n+\n+\n+class TestCLISubprocess:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\n+class TestRealWaveToneBackend:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"ready\"] is True\n+ assert any(check[\"name\"] == \"data/asdecoder.exe\" and check[\"ok\"] for check in data[\"checks\"])\n+ print(f\"\\n WaveTone root: {data['root']}\")\n+\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\n+ exe = wavetone_backend.find_wavetone()\n+ wav = make_wav(tmp_path / \"launch.wav\")\n+ result = self._run(\n+ [\n+ \"--json\",\n+ \"wavetone\",\n+ \"launch\",\n+ str(wav),\n+ \"--exe\",\n+ str(exe),\n+ \"--wait\",\n+ \"1\",\n+ \"--terminate\",\n+ ]\n+ )\n+ data = json.loads(result.stdout)[\"launch\"]\n+ assert data[\"backend\"] == \"wavetone.exe\"\n+ assert data[\"audio_path\"] == str(wav.resolve())\n+ assert data[\"running_after_wait\"] is True\n+ assert data[\"terminated\"] is True\n+ print(f\"\\n Launched WaveTone PID: {data['pid']}\")\n+ print(f\" WAV: {wav} ({wav.stat().st_size:,} bytes)\")\n"},{"comment":"Passing `\\\"wavetone\\\"` causes `ReplSkin` to derive a title-cased display name of `\\\"Wavetone\\\"`, which likely doesn’t match the product branding `\\\"WaveTone\\\"`. Consider passing `\\\"WaveTone\\\"` here (or adding a per-software display-name override in `ReplSkin`) to keep user-visible output consistent.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,369 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"wavetone\", version=__version__)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"},{"comment":"`self.skill_path` is computed and stored but not referenced anywhere else in this file (the banner currently prints `global_skill_path` instead). Either remove this unused detection to reduce complexity, or incorporate `self.skill_path` into the banner output so it has a clear purpose.","path":"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py","hunk":"@@ -0,0 +1,565 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ self.display_name = software.replace(\"_\", \" \").title()\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\nnew file mode 100644\nindex 000000000..3296206c8\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\n@@ -0,0 +1,568 @@\n+\"\"\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\n+\n+Copy this file into your CLI package at:\n+ cli_anything/<software>/utils/repl_skin.py\n+\n+Usage:\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\n+\n+ skin = ReplSkin(\"shotcut\", version=\"1.0.0\")\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\n+ prompt_text = skin.prompt(project_name=\"my_video.mlt\", modified=True)\n+ skin.success(\"Project saved\")\n+ skin.error(\"File not found\")\n+ skin.warning(\"Unsaved changes\")\n+ skin.info(\"Processing 24 clips...\")\n+ skin.status(\"Track 1\", \"3 clips, 00:02:30\")\n+ skin.table(headers, rows)\n+ skin.print_goodbye()\n+\"\"\"\n+\n+import os\n+import sys\n+from pathlib import Path\n+\n+# ── ANSI color codes (no external deps for core styling) ──────────────\n+\n+_RESET = \"\\033[0m\"\n+_BOLD = \"\\033[1m\"\n+_DIM = \"\\033[2m\"\n+_ITALIC = \"\\033[3m\"\n+_UNDERLINE = \"\\033[4m\"\n+\n+# Brand colors\n+_CYAN = \"\\033[38;5;80m\" # cli-anything brand cyan\n+_CYAN_BG = \"\\033[48;5;80m\"\n+_WHITE = \"\\033[97m\"\n+_GRAY = \"\\033[38;5;245m\"\n+_DARK_GRAY = \"\\033[38;5;240m\"\n+_LIGHT_GRAY = \"\\033[38;5;250m\"\n+\n+# Software accent colors — each software gets a unique accent\n+_ACCENT_COLORS = {\n+ \"gimp\": \"\\033[38;5;214m\", # warm orange\n+ \"blender\": \"\\033[38;5;208m\", # deep orange\n+ \"inkscape\": \"\\033[38;5;39m\", # bright blue\n+ \"audacity\": \"\\033[38;5;33m\", # navy blue\n+ \"libreoffice\": \"\\033[38;5;40m\", # green\n+ \"obs_studio\": \"\\033[38;5;55m\", # purple\n+ \"kdenlive\": \"\\033[38;5;69m\", # slate blue\n+ \"shotcut\": \"\\033[38;5;35m\", # teal green\n+}\n+_DEFAULT_ACCENT = \"\\033[38;5;75m\" # default sky blue\n+\n+# Status colors\n+_GREEN = \"\\033[38;5;78m\"\n+_YELLOW = \"\\033[38;5;220m\"\n+_RED = \"\\033[38;5;196m\"\n+_BLUE = \"\\033[38;5;75m\"\n+_MAGENTA = \"\\033[38;5;176m\"\n+\n+_SKILL_SOURCE_REPO = os.environ.get(\"CLI_ANYTHING_SKILL_REPO\", \"HKUDS/CLI-Anything\")\n+\n+# ── Brand icon ────────────────────────────────────────────────────────\n+\n+# The cli-anything icon: a small colored diamond/chevron mark\n+_ICON = f\"{_CYAN}{_BOLD}◆{_RESET}\"\n+_ICON_SMALL = f\"{_CYAN}▸{_RESET}\"\n+\n+# ── Box drawing characters ────────────────────────────────────────────\n+\n+_H_LINE = \"─\"\n+_V_LINE = \"│\"\n+_TL = \"╭\"\n+_TR = \"╮\"\n+_BL = \"╰\"\n+_BR = \"╯\"\n+_T_DOWN = \"┬\"\n+_T_UP = \"┴\"\n+_T_RIGHT = \"├\"\n+_T_LEFT = \"┤\"\n+_CROSS = \"┼\"\n+\n+\n+def _strip_ansi(text: str) -> str:\n+ \"\"\"Remove ANSI escape codes for length calculation.\"\"\"\n+ import re\n+ return re.sub(r\"\\033\\[[^m]*m\", \"\", text)\n+\n+\n+def _visible_len(text: str) -> int:\n+ \"\"\"Get visible length of text (excluding ANSI codes).\"\"\"\n+ return len(_strip_ansi(text))\n+\n+\n+def _display_home_path(path: str) -> str:\n+ \"\"\"Display a path relative to the home directory when possible.\"\"\"\n+ expanded = Path(path).expanduser().resolve()\n+ home = Path.home().resolve()\n+ try:\n+ relative = expanded.relative_to(home)\n+ return f\"~/{relative.as_posix()}\"\n+ except ValueError:\n+ return str(expanded)\n+\n+\n+class ReplSkin:\n+ \"\"\"Unified REPL skin for cli-anything CLIs.\n+\n+ Provides consistent branding, prompts, and message formatting\n+ across all CLI harnesses built with the cli-anything methodology.\n+ \"\"\"\n+\n+ def __init__(self, software: str, version: str = \"1.0.0\",\n+ history_file: str | None = None, skill_path: str | None = None):\n+ \"\"\"Initialize the REPL skin.\n+\n+ Args:\n+ software: Software name (e.g., \"gimp\", \"shotcut\", \"blender\").\n+ version: CLI version string.\n+ history_file: Path for persistent command history.\n+ Defaults to ~/.cli-anything-<software>/history\n+ skill_path: Path to the SKILL.md file for agent discovery.\n+ Auto-detected from the repo-root skills/ tree when present,\n+ otherwise from the package's skills/ directory.\n+ Displayed in banner for AI agents to know where to read skill info.\n+ \"\"\"\n+ self.software = software.lower().replace(\"-\", \"_\")\n+ display_overrides = {\"wavetone\": \"WaveTone\"}\n+ self.display_name = display_overrides.get(self.software, software.replace(\"_\", \" \").title())\n+ self.version = version\n+ software_aliases = {\"iterm2_ctl\": \"iterm2\"}\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\"_\", \"-\")\n+ self.skill_id = f\"cli-anything-{self.skill_slug}\"\n+ self.skill_install_cmd = (\n+ f\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\"\n+ )\n+ global_skill_root = Path(\n+ os.environ.get(\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\", str(Path.home() / \".agents\" / \"skills\"))\n+ ).expanduser()\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \"SKILL.md\")\n+\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\n+ if skill_path is None:\n+ package_skill = Path(__file__).resolve().parent.parent / \"skills\" / \"SKILL.md\"\n+ repo_skill = None\n+ for parent in Path(__file__).resolve().parents:\n+ candidate = parent / \"skills\" / self.skill_id / \"SKILL.md\"\n+ if candidate.is_file():\n+ repo_skill = candidate\n+ break\n+ if repo_skill and repo_skill.is_file():\n+ skill_path = str(repo_skill)\n+ elif package_skill.is_file():\n+ skill_path = str(package_skill)\n+ self.skill_path = skill_path\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\n+\n+ # History file\n+ if history_file is None:\n+ hist_dir = Path.home() / f\".cli-anything-{self.software}\"\n+ hist_dir.mkdir(parents=True, exist_ok=True)\n+ self.history_file = str(hist_dir / \"history\")\n+ else:\n+ self.history_file = history_file\n+\n+ # Detect terminal capabilities\n+ self._color = self._detect_color_support()\n+\n+ def _detect_color_support(self) -> bool:\n+ \"\"\"Check if terminal supports color.\"\"\"\n+ if os.environ.get(\"NO_COLOR\"):\n+ return False\n+ if os.environ.get(\"CLI_ANYTHING_NO_COLOR\"):\n+ return False\n+ if not hasattr(sys.stdout, \"isatty\"):\n+ return False\n+ return sys.stdout.isatty()\n+\n+ def _c(self, code: str, text: str) -> str:\n+ \"\"\"Apply color code if colors are supported.\"\"\"\n+ if not self._color:\n+ return text\n+ return f\"{code}{text}{_RESET}\"\n+\n+ # ── Banner ────────────────────────────────────────────────────────\n+\n+ def print_banner(self):\n+ \"\"\"Print the startup banner with branding.\"\"\"\n+ import textwrap\n+\n+ inner = 72\n+\n+ def _box_line(content: str) -> str:\n+ \"\"\"Wrap content in box drawing, padding to inner width.\"\"\"\n+ pad = inner - _visible_len(content)\n+ vl = self._c(_DARK_GRAY, _V_LINE)\n+ return f\"{vl}{content}{' ' * max(0, pad)}{vl}\"\n+\n+ def _meta_lines(label: str, value: str) -> list[str]:\n+ \"\"\"Wrap a metadata line for the banner box.\"\"\"\n+ icon = self._c(_MAGENTA, \"◇\")\n+ label_text = self._c(_DARK_GRAY, label)\n+ prefix = f\" {icon} {label_text} \"\n+ available = max(12, inner - _visible_len(prefix))\n+ wrapped = textwrap.wrap(\n+ value,\n+ width=available,\n+ break_long_words=True,\n+ break_on_hyphens=False,\n+ ) or [\"\"]\n+ lines = [f\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\"]\n+ continuation_prefix = \" \" * _visible_len(prefix)\n+ for chunk in wrapped[1:]:\n+ lines.append(f\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\")\n+ return lines\n+\n+ top = self._c(_DARK_GRAY, f\"{_TL}{_H_LINE * inner}{_TR}\")\n+ bot = self._c(_DARK_GRAY, f\"{_BL}{_H_LINE * inner}{_BR}\")\n+\n+ # Title: ◆ cli-anything · Shotcut\n+ icon = self._c(_CYAN + _BOLD, \"◆\")\n+ brand = self._c(_CYAN + _BOLD, \"cli-anything\")\n+ dot = self._c(_DARK_GRAY, \"·\")\n+ name = self._c(self.accent + _BOLD, self.display_name)\n+ title = f\" {icon} {brand} {dot} {name}\"\n+\n+ ver = f\" {self._c(_DARK_GRAY, f' v{self.version}')}\"\n+ tip = f\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\"\n+ empty = \"\"\n+\n+ meta_lines: list[str] = []\n+ meta_lines.extend(_meta_lines(\"Install:\", self.skill_install_cmd))\n+ if self.skill_path:\n+ meta_lines.extend(_meta_lines(\"Local skill:\", _display_home_path(self.skill_path)))\n+ meta_lines.extend(_meta_lines(\"Global skill:\", _display_home_path(self.global_skill_path)))\n+ print(top)\n+ print(_box_line(title))\n+ print(_box_line(ver))\n+ for line in meta_lines:\n+ print(_box_line(line))\n+ print(_box_line(empty))\n+ print(_box_line(tip))\n+ print(bot)\n+ print()\n+\n+ # ── Prompt ────────────────────────────────────────────────────────\n+\n+ def prompt(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\") -> str:\n+ \"\"\"Build a styled prompt string for prompt_toolkit or input().\n+\n+ Args:\n+ project_name: Current project name (empty if none open).\n+ modified: Whether the project has unsaved changes.\n+ context: Optional extra context to show in prompt.\n+\n+ Returns:\n+ Formatted prompt string.\n+ \"\"\"\n+ parts = []\n+\n+ # Icon\n+ if self._color:\n+ parts.append(f\"{_CYAN}◆{_RESET} \")\n+ else:\n+ parts.append(\"> \")\n+\n+ # Software name\n+ parts.append(self._c(self.accent + _BOLD, self.software))\n+\n+ # Project context\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ parts.append(f\" {self._c(_DARK_GRAY, '[')}\")\n+ parts.append(self._c(_LIGHT_GRAY, f\"{ctx}{mod}\"))\n+ parts.append(self._c(_DARK_GRAY, ']'))\n+\n+ parts.append(self._c(_GRAY, \" ❯ \"))\n+\n+ return \"\".join(parts)\n+\n+ def prompt_tokens(self, project_name: str = \"\", modified: bool = False,\n+ context: str = \"\"):\n+ \"\"\"Build prompt_toolkit formatted text tokens for the prompt.\n+\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\n+\n+ Returns:\n+ list of (style, text) tuples for prompt_toolkit.\n+ \"\"\"\n+ tokens = []\n+\n+ tokens.append((\"class:icon\", \"◆ \"))\n+ tokens.append((\"class:software\", self.software))\n+\n+ if project_name or context:\n+ ctx = context or project_name\n+ mod = \"*\" if modified else \"\"\n+ tokens.append((\"class:bracket\", \" [\"))\n+ tokens.append((\"class:context\", f\"{ctx}{mod}\"))\n+ tokens.append((\"class:bracket\", \"]\"))\n+\n+ tokens.append((\"class:arrow\", \" ❯ \"))\n+\n+ return tokens\n+\n+ def get_prompt_style(self):\n+ \"\"\"Get a prompt_toolkit Style object matching the skin.\n+\n+ Returns:\n+ prompt_toolkit.styles.Style\n+ \"\"\"\n+ try:\n+ from prompt_toolkit.styles import Style\n+ except ImportError:\n+ return None\n+\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \"#5fafff\")\n+\n+ return Style.from_dict({\n+ \"icon\": \"#5fdfdf bold\", # cyan brand color\n+ \"software\": f\"{accent_hex} bold\",\n+ \"bracket\": \"#585858\",\n+ \"context\": \"#bcbcbc\",\n+ \"arrow\": \"#808080\",\n+ # Completion menu\n+ \"completion-menu.completion\": \"bg:#303030 #bcbcbc\",\n+ \"completion-menu.completion.current\": f\"bg:{accent_hex} #000000\",\n+ \"completion-menu.meta.completion\": \"bg:#303030 #808080\",\n+ \"completion-menu.meta.completion.current\": f\"bg:{accent_hex} #000000\",\n+ # Auto-suggest\n+ \"auto-suggest\": \"#585858\",\n+ # Bottom toolbar\n+ \"bottom-toolbar\": \"bg:#1c1c1c #808080\",\n+ \"bottom-toolbar.text\": \"#808080\",\n+ })\n+\n+ # ── Messages ──────────────────────────────────────────────────────\n+\n+ def success(self, message: str):\n+ \"\"\"Print a success message with green checkmark.\"\"\"\n+ icon = self._c(_GREEN + _BOLD, \"✓\")\n+ print(f\" {icon} {self._c(_GREEN, message)}\")\n+\n+ def error(self, message: str):\n+ \"\"\"Print an error message with red cross.\"\"\"\n+ icon = self._c(_RED + _BOLD, \"✗\")\n+ print(f\" {icon} {self._c(_RED, message)}\", file=sys.stderr)\n+\n+ def warning(self, message: str):\n+ \"\"\"Print a warning message with yellow triangle.\"\"\"\n+ icon = self._c(_YELLOW + _BOLD, \"⚠\")\n+ print(f\" {icon} {self._c(_YELLOW, message)}\")\n+\n+ def info(self, message: str):\n+ \"\"\"Print an info message with blue dot.\"\"\"\n+ icon = self._c(_BLUE, \"●\")\n+ print(f\" {icon} {self._c(_LIGHT_GRAY, message)}\")\n+\n+ def hint(self, message: str):\n+ \"\"\"Print a subtle hint message.\"\"\"\n+ print(f\" {self._c(_DARK_GRAY, message)}\")\n+\n+ def section(self, title: str):\n+ \"\"\"Print a section header.\"\"\"\n+ print()\n+ print(f\" {self._c(self.accent + _BOLD, title)}\")\n+ print(f\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\")\n+\n+ # ── Status display ────────────────────────────────────────────────\n+\n+ def status(self, label: str, value: str):\n+ \"\"\"Print a key-value status line.\"\"\"\n+ lbl = self._c(_GRAY, f\" {label}:\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def status_block(self, items: dict[str, str], title: str = \"\"):\n+ \"\"\"Print a block of status key-value pairs.\n+\n+ Args:\n+ items: Dict of label -> value pairs.\n+ title: Optional title for the block.\n+ \"\"\"\n+ if title:\n+ self.section(title)\n+\n+ max_key = max(len(k) for k in items) if items else 0\n+ for label, value in items.items():\n+ lbl = self._c(_GRAY, f\" {label:<{max_key}}\")\n+ val = self._c(_WHITE, f\" {value}\")\n+ print(f\"{lbl}{val}\")\n+\n+ def progress(self, current: int, total: int, label: str = \"\"):\n+ \"\"\"Print a simple progress indicator.\n+\n+ Args:\n+ current: Current step number.\n+ total: Total number of steps.\n+ label: Optional label for the progress.\n+ \"\"\"\n+ pct = int(current / total * 100) if total > 0 else 0\n+ bar_width = 20\n+ filled = int(bar_width * current / total) if total > 0 else 0\n+ bar = \"█\" * filled + \"░\" * (bar_width - filled)\n+ text = f\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\"\n+ if label:\n+ text += f\" {self._c(_LIGHT_GRAY, label)}\"\n+ print(text)\n+\n+ # ── Table display ─────────────────────────────────────────────────\n+\n+ def table(self, headers: list[str], rows: list[list[str]],\n+ max_col_width: int = 40):\n+ \"\"\"Print a formatted table with box-drawing characters.\n+\n+ Args:\n+ headers: Column header strings.\n+ rows: List of rows, each a list of cell strings.\n+ max_col_width: Maximum column width before truncation.\n+ \"\"\"\n+ if not headers:\n+ return\n+\n+ # Calculate column widths\n+ col_widths = [min(len(h), max_col_width) for h in headers]\n+ for row in rows:\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ col_widths[i] = min(\n+ max(col_widths[i], len(str(cell))), max_col_width\n+ )\n+\n+ def pad(text: str, width: int) -> str:\n+ t = str(text)[:width]\n+ return t + \" \" * (width - len(t))\n+\n+ # Header\n+ header_cells = [\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\n+ for i, h in enumerate(headers)\n+ ]\n+ sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ header_line = f\" {sep.join(header_cells)}\"\n+ print(header_line)\n+\n+ # Separator\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\n+ sep_line = f\" {sep.join(sep_parts)}\"\n+ print(sep_line)\n+\n+ # Rows\n+ for row in rows:\n+ cells = []\n+ for i, cell in enumerate(row):\n+ if i < len(col_widths):\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\n+ row_sep = self._c(_DARK_GRAY, f\" {_V_LINE} \")\n+ print(f\" {row_sep.join(cells)}\")\n+\n+ # ── Help display ──────────────────────────────────────────────────\n+\n+ def help(self, commands: dict[str, str]):\n+ \"\"\"Print a formatted help listing.\n+\n+ Args:\n+ commands: Dict of command -> description pairs.\n+ \"\"\"\n+ self.section(\"Commands\")\n+ max_cmd = max(len(c) for c in commands) if commands else 0\n+ for cmd, desc in commands.items():\n+ cmd_styled = self._c(self.accent, f\" {cmd:<{max_cmd}}\")\n+ desc_styled = self._c(_GRAY, f\" {desc}\")\n+ print(f\"{cmd_styled}{desc_styled}\")\n+ print()\n+\n+ # ── Goodbye ───────────────────────────────────────────────────────\n+\n+ def print_goodbye(self):\n+ \"\"\"Print a styled goodbye message.\"\"\"\n+ print(f\"\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\n\")\n+\n+ # ── Prompt toolkit session factory ────────────────────────────────\n+\n+ def create_prompt_session(self):\n+ \"\"\"Create a prompt_toolkit PromptSession with skin styling.\n+\n+ Returns:\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\n+ \"\"\"\n+ try:\n+ from prompt_toolkit import PromptSession\n+ from prompt_toolkit.history import FileHistory\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\n+\n+ style = self.get_prompt_style()\n+\n+ session = PromptSession(\n+ history=FileHistory(self.history_file),\n+ auto_suggest=AutoSuggestFromHistory(),\n+ style=style,\n+ enable_history_search=True,\n+ )\n+ return session\n+ except ImportError:\n+ return None\n+\n+ def get_input(self, pt_session, project_name: str = \"\",\n+ modified: bool = False, context: str = \"\") -> str:\n+ \"\"\"Get input from user using prompt_toolkit or fallback.\n+\n+ Args:\n+ pt_session: A prompt_toolkit PromptSession (or None).\n+ project_name: Current project name.\n+ modified: Whether project has unsaved changes.\n+ context: Optional context string.\n+\n+ Returns:\n+ User input string (stripped).\n+ \"\"\"\n+ if pt_session is not None:\n+ from prompt_toolkit.formatted_text import FormattedText\n+ tokens = self.prompt_tokens(project_name, modified, context)\n+ return pt_session.prompt(FormattedText(tokens)).strip()\n+ else:\n+ raw_prompt = self.prompt(project_name, modified, context)\n+ return input(raw_prompt).strip()\n+\n+ # ── Toolbar builder ───────────────────────────────────────────────\n+\n+ def bottom_toolbar(self, items: dict[str, str]):\n+ \"\"\"Create a bottom toolbar callback for prompt_toolkit.\n+\n+ Args:\n+ items: Dict of label -> value pairs to show in toolbar.\n+\n+ Returns:\n+ A callable that returns FormattedText for the toolbar.\n+ \"\"\"\n+ def toolbar():\n+ from prompt_toolkit.formatted_text import FormattedText\n+ parts = []\n+ for i, (k, v) in enumerate(items.items()):\n+ if i > 0:\n+ parts.append((\"class:bottom-toolbar.text\", \" │ \"))\n+ parts.append((\"class:bottom-toolbar.text\", f\" {k}: \"))\n+ parts.append((\"class:bottom-toolbar\", v))\n+ return FormattedText(parts)\n+ return toolbar\n+\n+\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\n+\n+_ANSI_256_TO_HEX = {\n+ \"\\033[38;5;33m\": \"#0087ff\", # audacity navy blue\n+ \"\\033[38;5;35m\": \"#00af5f\", # shotcut teal\n+ \"\\033[38;5;39m\": \"#00afff\", # inkscape bright blue\n+ \"\\033[38;5;40m\": \"#00d700\", # libreoffice green\n+ \"\\033[38;5;55m\": \"#5f00af\", # obs purple\n+ \"\\033[38;5;69m\": \"#5f87ff\", # kdenlive slate blue\n+ \"\\033[38;5;75m\": \"#5fafff\", # default sky blue\n+ \"\\033[38;5;80m\": \"#5fd7d7\", # brand cyan\n+ \"\\033[38;5;208m\": \"#ff8700\", # blender deep orange\n+ \"\\033[38;5;214m\": \"#ffaf00\", # gimp warm orange\n+}\n"},{"comment":"`CLI_BASE` is computed at import/collection time and depends on the ambient `CLI_ANYTHING_FORCE_INSTALLED` environment variable. If a developer/CI environment has that variable set, this test class will switch to the installed entry point and can fail unexpectedly (e.g., binary not installed), even though the suite intends source-module default behavior. Consider resolving the CLI base inside `_run()` (or via a fixture) after explicitly clearing/controlling `CLI_ANYTHING_FORCE_INSTALLED`, so the tests are deterministic regardless of external env.","path":"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py","hunk":"@@ -0,0 +1,152 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str) -> list[str]:\n+ \"\"\"Run the in-tree module by default; installed entry points are opt-in.\"\"\"\n+ force = os.environ.get(\"CLI_ANYTHING_FORCE_INSTALLED\", \"\").strip() == \"1\"\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ if not force:\n+ print(f\"[_resolve_cli] Using source module: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+ path = shutil.which(name)\n+ if not path:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+\n+\n+def _env_flag_enabled(name: str) -> bool:\n+ return os.environ.get(name, \"\").strip().lower() in {\"1\", \"true\", \"yes\", \"on\"}\n+\n+\n+def _real_backend_ready() -> tuple[bool, str]:\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\n+ return False, f\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+ if sys.platform != \"win32\":\n+ return False, \"WaveTone real-backend tests require Windows\"\n+ if not (os.environ.get(\"WAVETONE_EXE\") or os.environ.get(\"WAVETONE_HOME\")):\n+ return False, \"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+\n+ status = wavetone_backend.doctor()\n+ if status.get(\"ready\"):\n+ return True, \"\"\n+\n+ failed_checks = [check[\"name\"] for check in status.get(\"checks\", []) if not check.get(\"ok\")]\n+ reason = \", \".join(failed_checks) if failed_checks else \"WaveTone backend is not ready\"\n+ return False, f\"WaveTone real backend unavailable: {reason}\"\n+\n+\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\n+\n+\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\n+ monkeypatch.delenv(\"WAVETONE_EXE\", raising=False)\n+ monkeypatch.delenv(\"WAVETONE_HOME\", raising=False)\n+\n+ ready, reason = _real_backend_ready()\n+\n+ assert ready is False\n+ assert REAL_BACKEND_ENV in reason\n+\n+\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(\"CLI_ANYTHING_FORCE_INSTALLED\", raising=False)\n+ monkeypatch.setattr(shutil, \"which\", lambda name: \"C:/foreign/cli-anything-wavetone.exe\")\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\") == [sys.executable, \"-m\", \"cli_anything.wavetone.wavetone_cli\"]\n+\n+\n+class TestCLISubprocess:\n+ CLI_BASE = _resolve_cli(\"cli-anything-wavetone\")\n+\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2ceb45661\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\n@@ -0,0 +1,153 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\n+ \"\"\"Run the in-tree module by default; installed entry points are opt-in.\"\"\"\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ if not force_installed:\n+ print(f\"[_resolve_cli] Using source module: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+ path = shutil.which(name)\n+ if not path:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+\n+\n+def _env_flag_enabled(name: str) -> bool:\n+ return os.environ.get(name, \"\").strip().lower() in {\"1\", \"true\", \"yes\", \"on\"}\n+\n+\n+def _real_backend_ready() -> tuple[bool, str]:\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\n+ return False, f\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+ if sys.platform != \"win32\":\n+ return False, \"WaveTone real-backend tests require Windows\"\n+ if not (os.environ.get(\"WAVETONE_EXE\") or os.environ.get(\"WAVETONE_HOME\")):\n+ return False, \"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+\n+ status = wavetone_backend.doctor()\n+ if status.get(\"ready\"):\n+ return True, \"\"\n+\n+ failed_checks = [check[\"name\"] for check in status.get(\"checks\", []) if not check.get(\"ok\")]\n+ reason = \", \".join(failed_checks) if failed_checks else \"WaveTone backend is not ready\"\n+ return False, f\"WaveTone real backend unavailable: {reason}\"\n+\n+\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\n+\n+\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\n+ monkeypatch.delenv(\"WAVETONE_EXE\", raising=False)\n+ monkeypatch.delenv(\"WAVETONE_HOME\", raising=False)\n+\n+ ready, reason = _real_backend_ready()\n+\n+ assert ready is False\n+ assert REAL_BACKEND_ENV in reason\n+\n+\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setenv(\"CLI_ANYTHING_FORCE_INSTALLED\", \"1\")\n+ monkeypatch.setattr(shutil, \"which\", lambda name: pytest.fail(\"default resolver should not inspect PATH\"))\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\") == [sys.executable, \"-m\", \"cli_anything.wavetone.wavetone_cli\"]\n+\n+\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setattr(shutil, \"which\", lambda name: \"C:/installed/cli-anything-wavetone.exe\")\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\", force_installed=True) == [\"C:/installed/cli-anything-wavetone.exe\"]\n+\n+\n+class TestCLISubprocess:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\n+class TestRealWaveToneBackend:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"ready\"] is True\n+ assert any(check[\"name\"] == \"data/asdecoder.exe\" and check[\"ok\"] for check in data[\"checks\"])\n+ print(f\"\\n WaveTone root: {data['root']}\")\n+\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\n+ exe = wavetone_backend.find_wavetone()\n+ wav = make_wav(tmp_path / \"launch.wav\")\n+ result = self._run(\n+ [\n+ \"--json\",\n+ \"wavetone\",\n+ \"launch\",\n+ str(wav),\n+ \"--exe\",\n+ str(exe),\n+ \"--wait\",\n+ \"1\",\n+ \"--terminate\",\n+ ]\n+ )\n+ data = json.loads(result.stdout)[\"launch\"]\n+ assert data[\"backend\"] == \"wavetone.exe\"\n+ assert data[\"audio_path\"] == str(wav.resolve())\n+ assert data[\"running_after_wait\"] is True\n+ assert data[\"terminated\"] is True\n+ print(f\"\\n Launched WaveTone PID: {data['pid']}\")\n+ print(f\" WAV: {wav} ({wav.stat().st_size:,} bytes)\")\n"},{"comment":"`attach-wfd` is described as attaching a WaveTone-saved WFD file, but the `wfd_path` argument does not require the file to exist (`exists=True` is missing). This allows persisting manifests with invalid/nonexistent WFD paths without any immediate feedback. If the intent is to attach an actual saved WFD, make `wfd_path` validate existence (and optionally validate the `.wfd` suffix) to catch mistakes early.","path":"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py","hunk":"@@ -0,0 +1,369 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"","resolving_sha":"f5b2212c84cb3490fa96735f33c05e9601f6cf8b","resolving_diff":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\nnew file mode 100644\nindex 000000000..2df5646f0\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\n@@ -0,0 +1,371 @@\n+\"\"\"Click CLI for WaveTone 2.61.\"\"\"\n+\n+from __future__ import annotations\n+\n+import json\n+import shlex\n+from pathlib import Path\n+from typing import Any\n+\n+import click\n+\n+from cli_anything.wavetone import __version__\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ project_summary,\n+ save_project,\n+ set_tempo,\n+ set_wfd_path,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+\n+\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\n+ if json_mode:\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\n+ return\n+ for key, value in data.items():\n+ if isinstance(value, (dict, list)):\n+ click.echo(f\"{key}: {json.dumps(value, sort_keys=True)}\")\n+ else:\n+ click.echo(f\"{key}: {value}\")\n+\n+\n+def ctx_json(ctx: click.Context) -> bool:\n+ return bool(ctx.obj and ctx.obj.get(\"json\"))\n+\n+\n+def ctx_project(ctx: click.Context) -> Path | None:\n+ value = ctx.obj.get(\"project\") if ctx.obj else None\n+ return Path(value).expanduser().resolve() if value else None\n+\n+\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\n+ if not path:\n+ raise click.ClickException(\"Project path required. Use --project PATH or pass a project argument.\")\n+ return load_project(path), path\n+\n+\n+def _strip_matching_quotes(value: str) -> str:\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\"'\", '\"'}:\n+ return value[1:-1]\n+ return value\n+\n+\n+def _split_repl_args(line: str) -> list[str]:\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\n+\n+\n+@click.group(invoke_without_command=True)\n+@click.option(\"--project\", \"project_path\", type=click.Path(dir_okay=False), help=\"WaveTone project JSON path.\")\n+@click.option(\"--json\", \"json_mode\", is_flag=True, help=\"Emit machine-readable JSON.\")\n+@click.version_option(version=__version__, prog_name=\"cli-anything-wavetone\")\n+@click.pass_context\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\n+ \"\"\"Agent-native CLI harness for WaveTone 2.61.\"\"\"\n+ ctx.ensure_object(dict)\n+ if project_path is not None:\n+ ctx.obj[\"project\"] = project_path\n+ else:\n+ ctx.obj.setdefault(\"project\", None)\n+ if json_mode:\n+ ctx.obj[\"json\"] = True\n+ else:\n+ ctx.obj.setdefault(\"json\", False)\n+ if ctx.invoked_subcommand is None:\n+ ctx.invoke(repl)\n+\n+\n+@cli.command()\n+@click.pass_context\n+def repl(ctx: click.Context) -> None:\n+ \"\"\"Start an interactive command loop.\"\"\"\n+ skin = ReplSkin(\"WaveTone\", version=__version__)\n+ skin.print_banner()\n+ skin.info(\"Type 'help' for commands, 'exit' to quit.\")\n+ prompt_session = skin.create_prompt_session()\n+ while True:\n+ try:\n+ line = skin.get_input(prompt_session, project_name=\"wavetone\", modified=False)\n+ except (EOFError, KeyboardInterrupt):\n+ break\n+ line = line.strip()\n+ if not line:\n+ continue\n+ if line in {\"exit\", \"quit\"}:\n+ break\n+ if line == \"help\":\n+ click.echo(cli.get_help(ctx))\n+ continue\n+ try:\n+ args = _split_repl_args(line)\n+ cli.main(args=args, prog_name=\"cli-anything-wavetone\", standalone_mode=False, obj=ctx.obj)\n+ except click.ClickException as exc: # pragma: no cover\n+ skin.error(exc.format_message())\n+ except click.exceptions.Exit as exc: # pragma: no cover\n+ if exc.exit_code not in (0, None):\n+ skin.error(f\"Command exited with code {exc.exit_code}\")\n+ except Exception as exc: # pragma: no cover\n+ skin.error(f\"Unexpected error: {exc}\")\n+ skin.print_goodbye()\n+\n+\n+@cli.group(name=\"project\")\n+def project_group() -> None:\n+ \"\"\"Create and edit WaveTone project manifests.\"\"\"\n+\n+\n+@project_group.command(\"new\")\n+@click.argument(\"audio_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"-o\", \"--output\", \"output_path\", type=click.Path(dir_okay=False), required=True)\n+@click.option(\"--name\", help=\"Project name. Defaults to the audio file stem.\")\n+@click.pass_context\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\n+ \"\"\"Create a WaveTone project manifest for an audio file.\"\"\"\n+ try:\n+ project = create_project(audio_path, name=name)\n+ path = save_project(project, output_path)\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"info\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\n+ \"\"\"Inspect a WaveTone project manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"project\": project_summary(project)}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"add-label\")\n+@click.argument(\"name\")\n+@click.option(\"--time\", \"time_seconds\", type=float, required=True, help=\"Label time in seconds.\")\n+@click.option(\"--note\", help=\"Optional label note.\")\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\n+ \"\"\"Add a navigation label to the manifest.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"labels\": project.get(\"labels\", [])}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"set-tempo\")\n+@click.option(\"--bpm\", type=float, required=True)\n+@click.option(\"--first-bar\", \"first_bar_time_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--meter\", default=\"4/4\", show_default=True)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\n+ \"\"\"Set the tempo plan WaveTone should use before chord or note work.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"tempo\": project.get(\"tempo\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"analysis\")\n+@click.option(\"--blocks-per-second\", type=int)\n+@click.option(\"--blocks-per-semitone\", type=int)\n+@click.option(\"--note-range\")\n+@click.option(\"--reference-frequency-hz\", type=float)\n+@click.option(\"--channel\", type=click.Choice([\"Stereo\", \"L-R\", \"L+R\", \"L\", \"R\"]))\n+@click.option(\"--fundamental\", \"fundamental\", flag_value=True, default=None)\n+@click.option(\"--no-fundamental\", \"fundamental\", flag_value=False, default=None)\n+@click.option(\"--skip-dialog\", \"skip_dialog\", flag_value=True, default=None)\n+@click.option(\"--show-dialog\", \"skip_dialog\", flag_value=False, default=None)\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_analysis(\n+ ctx: click.Context,\n+ blocks_per_second: int | None,\n+ blocks_per_semitone: int | None,\n+ note_range: str | None,\n+ reference_frequency_hz: float | None,\n+ channel: str | None,\n+ fundamental: bool | None,\n+ skip_dialog: bool | None,\n+ project_path: str | None,\n+) -> None:\n+ \"\"\"Update intended WaveTone analysis settings.\"\"\"\n+ try:\n+ project, path = load_ctx_project(ctx, project_path)\n+ update_analysis(\n+ project,\n+ blocks_per_second=blocks_per_second,\n+ blocks_per_semitone=blocks_per_semitone,\n+ note_range=note_range,\n+ reference_frequency_hz=reference_frequency_hz,\n+ channel=channel,\n+ analyze_fundamental_frequency=fundamental,\n+ skip_analysis_dialog=skip_dialog,\n+ )\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"analysis\": project.get(\"analysis\")}, ctx_json(ctx))\n+\n+\n+@project_group.command(\"attach-wfd\")\n+@click.argument(\"wfd_path\", type=click.Path(exists=True, dir_okay=False))\n+@click.argument(\"project_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\n+ \"\"\"Attach a WFD analysis file saved by WaveTone.\"\"\"\n+ try:\n+ if Path(wfd_path).suffix.lower() != \".wfd\":\n+ raise ValueError(\"WFD path must use the .wfd extension\")\n+ project, path = load_ctx_project(ctx, project_path)\n+ set_wfd_path(project, wfd_path)\n+ save_project(project, path)\n+ except (OSError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"project_path\": str(path), \"wfd_path\": project.get(\"wfd_path\")}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"audio\")\n+def audio_group() -> None:\n+ \"\"\"Probe audio files before opening them in WaveTone.\"\"\"\n+\n+\n+@audio_group.command(\"probe\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.pass_context\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\n+ \"\"\"Return duration, sample rate, channel, codec, and size metadata.\"\"\"\n+ try:\n+ if audio_path:\n+ target = audio_path\n+ else:\n+ project, _ = load_ctx_project(ctx)\n+ target = project[\"audio\"][\"path\"]\n+ data = probe_audio(target)\n+ except (OSError, ValueError, RuntimeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"audio\": data}, ctx_json(ctx))\n+\n+\n+@cli.group(name=\"wavetone\")\n+def wavetone_group() -> None:\n+ \"\"\"Inspect and launch the real WaveTone executable.\"\"\"\n+\n+\n+@wavetone_group.command(\"doctor\")\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.pass_context\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\n+ \"\"\"Check whether WaveTone and its bundled decoder files are available.\"\"\"\n+ data = wavetone_backend.doctor(executable)\n+ emit(data, ctx_json(ctx))\n+ if not data.get(\"ready\"):\n+ raise click.exceptions.Exit(1)\n+\n+\n+@wavetone_group.command(\"formats\")\n+@click.pass_context\n+def wavetone_formats(ctx: click.Context) -> None:\n+ \"\"\"List audio formats documented by WaveTone 2.61.\"\"\"\n+ emit({\"ok\": True, \"formats\": wavetone_backend.supported_formats()}, ctx_json(ctx))\n+\n+\n+@wavetone_group.command(\"launch\")\n+@click.argument(\"audio_path\", required=False, type=click.Path(exists=True, dir_okay=False))\n+@click.option(\"--exe\", \"executable\", type=click.Path(dir_okay=False), help=\"Path to wavetone.exe.\")\n+@click.option(\"--wait\", \"wait_seconds\", type=float, default=0.0, show_default=True)\n+@click.option(\"--terminate\", is_flag=True, help=\"Terminate after the wait period, useful for smoke tests.\")\n+@click.pass_context\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\n+ \"\"\"Launch the real WaveTone GUI, optionally with an audio file.\"\"\"\n+ try:\n+ target = audio_path\n+ if not target:\n+ project_path = ctx_project(ctx)\n+ if project_path:\n+ project = load_project(project_path)\n+ target = project[\"audio\"][\"path\"]\n+ data = wavetone_backend.launch_wavetone(\n+ audio_path=target,\n+ executable=executable,\n+ wait_seconds=wait_seconds,\n+ terminate=terminate,\n+ )\n+ except (OSError, RuntimeError, ValueError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ failed_launch = (\n+ wait_seconds > 0\n+ and not data.get(\"running_after_wait\")\n+ and not data.get(\"terminated\")\n+ and data.get(\"exit_code\") not in (None, 0)\n+ )\n+ emit({\"ok\": not failed_launch, \"launch\": data}, ctx_json(ctx))\n+ if failed_launch:\n+ raise click.exceptions.Exit(int(data.get(\"exit_code\") or 1))\n+\n+\n+@cli.group(name=\"session\")\n+def session_group() -> None:\n+ \"\"\"Record lightweight CLI session events.\"\"\"\n+\n+\n+@session_group.command(\"record\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.argument(\"event\")\n+@click.option(\"--payload\", default=\"{}\", help=\"JSON object payload.\")\n+@click.pass_context\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\n+ \"\"\"Append an event to a session log.\"\"\"\n+ try:\n+ payload_data = json.loads(payload)\n+ if not isinstance(payload_data, dict):\n+ raise ValueError(\"Payload must be a JSON object\")\n+ record = append_event(session_path, event, payload_data)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"event\": record}, ctx_json(ctx))\n+\n+\n+@session_group.command(\"events\")\n+@click.argument(\"session_path\", type=click.Path(dir_okay=False))\n+@click.pass_context\n+def session_events(ctx: click.Context, session_path: str) -> None:\n+ \"\"\"List session events.\"\"\"\n+ try:\n+ events = load_events(session_path)\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\n+ raise click.ClickException(str(exc)) from exc\n+ emit({\"ok\": True, \"events\": events}, ctx_json(ctx))\n+\n+\n+@cli.command(\"defaults\")\n+@click.pass_context\n+def defaults(ctx: click.Context) -> None:\n+ \"\"\"Show default WaveTone analysis settings used in new manifests.\"\"\"\n+ emit({\"ok\": True, \"analysis_defaults\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\n+\n+\n+def main() -> None:\n+ cli(obj={})\n+\n+\n+if __name__ == \"__main__\":\n+ main()\n"}],"string":"[\n {\n \"comment\": \"The “real backend” tests are unconditional and will fail on non-Windows hosts or in CI environments where WaveTone isn’t installed/configured (e.g., `doctor` asserts `ready is True`). Consider marking `TestRealWaveToneBackend` (or its tests) with `pytest.mark.skipif` based on platform and/or presence of `WAVETONE_EXE`/`WAVETONE_HOME`, or put them behind an opt-in marker (e.g., `-m real_backend`) so default test runs remain reliable.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\",\n \"hunk\": \"@@ -0,0 +1,118 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+import os\\n+import shutil\\n+import struct\\n+import subprocess\\n+import sys\\n+import wave\\n+from pathlib import Path\\n+\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+\\n+def make_wav(path: Path, freq: float = 440.0, duration: float = 0.5, sample_rate: int = 8000) -> Path:\\n+ frames = int(duration * sample_rate)\\n+ with wave.open(str(path), \\\"wb\\\") as handle:\\n+ handle.setnchannels(1)\\n+ handle.setsampwidth(2)\\n+ handle.setframerate(sample_rate)\\n+ for idx in range(frames):\\n+ sample = int(16000 * math.sin(2 * math.pi * freq * idx / sample_rate))\\n+ handle.writeframes(struct.pack(\\\"<h\\\", sample))\\n+ return path\\n+\\n+\\n+def _resolve_cli(name: str) -> list[str]:\\n+ \\\"\\\"\\\"Resolve installed CLI command; fall back to python -m for development.\\\"\\\"\\\"\\n+ force = os.environ.get(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"\\\").strip() == \\\"1\\\"\\n+ path = shutil.which(name)\\n+ if path:\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+ if force:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ print(f\\\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+\\n+class TestCLISubprocess:\\n+ CLI_BASE = _resolve_cli(\\\"cli-anything-wavetone\\\")\\n+\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_help(self) -> None:\\n+ result = self._run([\\\"--help\\\"])\\n+ assert \\\"Agent-native CLI harness for WaveTone\\\" in result.stdout\\n+\\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\\n+ wav = make_wav(tmp_path / \\\"tone.wav\\\")\\n+ project = tmp_path / \\\"tone.wt.json\\\"\\n+\\n+ result = self._run([\\\"--json\\\", \\\"project\\\", \\\"new\\\", str(wav), \\\"-o\\\", str(project)])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ok\\\"] is True\\n+ assert project.exists()\\n+\\n+ result = self._run(\\n+ [\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"set-tempo\\\", \\\"--bpm\\\", \\\"132.5\\\", \\\"--first-bar\\\", \\\"0.1\\\"]\\n+ )\\n+ assert json.loads(result.stdout)[\\\"tempo\\\"][\\\"bpm\\\"] == 132.5\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"add-label\\\", \\\"intro\\\", \\\"--time\\\", \\\"0.25\\\"])\\n+ assert json.loads(result.stdout)[\\\"labels\\\"][0][\\\"name\\\"] == \\\"intro\\\"\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"audio\\\", \\\"probe\\\"])\\n+ audio = json.loads(result.stdout)[\\\"audio\\\"]\\n+ assert audio[\\\"duration_seconds\\\"] == 0.5\\n+ assert audio[\\\"channels\\\"] == 1\\n+ print(f\\\"\\\\n Project: {project}\\\")\\n+ print(f\\\" Audio: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n+\\n+ def test_formats_json(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"formats\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert \\\".wav\\\" in data[\\\"formats\\\"][\\\"extensions\\\"]\\n+ assert \\\"MP3\\\" in data[\\\"formats\\\"][\\\"from_readme\\\"]\\n+\\n+\\n+class TestRealWaveToneBackend:\\n+ CLI_BASE = _resolve_cli(\\\"cli-anything-wavetone\\\")\\n+\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_doctor_real_backend(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"doctor\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ready\\\"] is True\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\nnew file mode 100644\\nindex 000000000..2ceb45661\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\n@@ -0,0 +1,153 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shutil\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.tests.helpers import make_wav\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+REAL_BACKEND_ENV = \\\"CLI_ANYTHING_WAVETONE_REAL_BACKEND\\\"\\n+\\n+\\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\\n+ \\\"\\\"\\\"Run the in-tree module by default; installed entry points are opt-in.\\\"\\\"\\\"\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ if not force_installed:\\n+ print(f\\\"[_resolve_cli] Using source module: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+ path = shutil.which(name)\\n+ if not path:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+\\n+\\n+def _env_flag_enabled(name: str) -> bool:\\n+ return os.environ.get(name, \\\"\\\").strip().lower() in {\\\"1\\\", \\\"true\\\", \\\"yes\\\", \\\"on\\\"}\\n+\\n+\\n+def _real_backend_ready() -> tuple[bool, str]:\\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\\n+ return False, f\\\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+ if sys.platform != \\\"win32\\\":\\n+ return False, \\\"WaveTone real-backend tests require Windows\\\"\\n+ if not (os.environ.get(\\\"WAVETONE_EXE\\\") or os.environ.get(\\\"WAVETONE_HOME\\\")):\\n+ return False, \\\"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+\\n+ status = wavetone_backend.doctor()\\n+ if status.get(\\\"ready\\\"):\\n+ return True, \\\"\\\"\\n+\\n+ failed_checks = [check[\\\"name\\\"] for check in status.get(\\\"checks\\\", []) if not check.get(\\\"ok\\\")]\\n+ reason = \\\", \\\".join(failed_checks) if failed_checks else \\\"WaveTone backend is not ready\\\"\\n+ return False, f\\\"WaveTone real backend unavailable: {reason}\\\"\\n+\\n+\\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\\n+\\n+\\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_EXE\\\", raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_HOME\\\", raising=False)\\n+\\n+ ready, reason = _real_backend_ready()\\n+\\n+ assert ready is False\\n+ assert REAL_BACKEND_ENV in reason\\n+\\n+\\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setenv(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"1\\\")\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: pytest.fail(\\\"default resolver should not inspect PATH\\\"))\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\") == [sys.executable, \\\"-m\\\", \\\"cli_anything.wavetone.wavetone_cli\\\"]\\n+\\n+\\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: \\\"C:/installed/cli-anything-wavetone.exe\\\")\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\", force_installed=True) == [\\\"C:/installed/cli-anything-wavetone.exe\\\"]\\n+\\n+\\n+class TestCLISubprocess:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_help(self) -> None:\\n+ result = self._run([\\\"--help\\\"])\\n+ assert \\\"Agent-native CLI harness for WaveTone\\\" in result.stdout\\n+\\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\\n+ wav = make_wav(tmp_path / \\\"tone.wav\\\")\\n+ project = tmp_path / \\\"tone.wt.json\\\"\\n+\\n+ result = self._run([\\\"--json\\\", \\\"project\\\", \\\"new\\\", str(wav), \\\"-o\\\", str(project)])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ok\\\"] is True\\n+ assert project.exists()\\n+\\n+ result = self._run(\\n+ [\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"set-tempo\\\", \\\"--bpm\\\", \\\"132.5\\\", \\\"--first-bar\\\", \\\"0.1\\\"]\\n+ )\\n+ assert json.loads(result.stdout)[\\\"tempo\\\"][\\\"bpm\\\"] == 132.5\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"add-label\\\", \\\"intro\\\", \\\"--time\\\", \\\"0.25\\\"])\\n+ assert json.loads(result.stdout)[\\\"labels\\\"][0][\\\"name\\\"] == \\\"intro\\\"\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"audio\\\", \\\"probe\\\"])\\n+ audio = json.loads(result.stdout)[\\\"audio\\\"]\\n+ assert audio[\\\"duration_seconds\\\"] == 0.5\\n+ assert audio[\\\"channels\\\"] == 1\\n+ print(f\\\"\\\\n Project: {project}\\\")\\n+ print(f\\\" Audio: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n+\\n+ def test_formats_json(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"formats\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert \\\".wav\\\" in data[\\\"formats\\\"][\\\"extensions\\\"]\\n+ assert \\\"MP3\\\" in data[\\\"formats\\\"][\\\"from_readme\\\"]\\n+\\n+\\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\\n+class TestRealWaveToneBackend:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_doctor_real_backend(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"doctor\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ready\\\"] is True\\n+ assert any(check[\\\"name\\\"] == \\\"data/asdecoder.exe\\\" and check[\\\"ok\\\"] for check in data[\\\"checks\\\"])\\n+ print(f\\\"\\\\n WaveTone root: {data['root']}\\\")\\n+\\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\\n+ exe = wavetone_backend.find_wavetone()\\n+ wav = make_wav(tmp_path / \\\"launch.wav\\\")\\n+ result = self._run(\\n+ [\\n+ \\\"--json\\\",\\n+ \\\"wavetone\\\",\\n+ \\\"launch\\\",\\n+ str(wav),\\n+ \\\"--exe\\\",\\n+ str(exe),\\n+ \\\"--wait\\\",\\n+ \\\"1\\\",\\n+ \\\"--terminate\\\",\\n+ ]\\n+ )\\n+ data = json.loads(result.stdout)[\\\"launch\\\"]\\n+ assert data[\\\"backend\\\"] == \\\"wavetone.exe\\\"\\n+ assert data[\\\"audio_path\\\"] == str(wav.resolve())\\n+ assert data[\\\"running_after_wait\\\"] is True\\n+ assert data[\\\"terminated\\\"] is True\\n+ print(f\\\"\\\\n Launched WaveTone PID: {data['pid']}\\\")\\n+ print(f\\\" WAV: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n\"\n },\n {\n \"comment\": \"Catching all exceptions and printing `str(exc)` can produce unhelpful output for Click-specific control flow (e.g., `click.exceptions.Exit(1)` prints just `1`). Handle `click.ClickException` and `click.exceptions.Exit` explicitly so the REPL prints a meaningful message (and optionally continues/returns based on exit code) while still keeping a final broad catch for unexpected errors.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,339 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ ctx.obj[\\\"json\\\"] = json_mode\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"wavetone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = shlex.split(line, posix=(os.name != \\\"nt\\\"))\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(str(exc))\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"The table separator construction is inconsistent: `sep_parts` is computed but not used, and the join string `'───'` hardcodes spacing/thickness in a way that can misalign with the header separator (`_V_LINE`). Build the separator line using the same column widths and the same delimiter logic as the header (or reuse `sep_parts`) so the rendered table consistently aligns.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\",\n \"hunk\": \"@@ -0,0 +1,567 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ self.display_name = software.replace(\\\"_\\\", \\\" \\\").title()\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\\n+\\n+ # History file\\n+ if history_file is None:\\n+ hist_dir = Path.home() / f\\\".cli-anything-{self.software}\\\"\\n+ hist_dir.mkdir(parents=True, exist_ok=True)\\n+ self.history_file = str(hist_dir / \\\"history\\\")\\n+ else:\\n+ self.history_file = history_file\\n+\\n+ # Detect terminal capabilities\\n+ self._color = self._detect_color_support()\\n+\\n+ def _detect_color_support(self) -> bool:\\n+ \\\"\\\"\\\"Check if terminal supports color.\\\"\\\"\\\"\\n+ if os.environ.get(\\\"NO_COLOR\\\"):\\n+ return False\\n+ if os.environ.get(\\\"CLI_ANYTHING_NO_COLOR\\\"):\\n+ return False\\n+ if not hasattr(sys.stdout, \\\"isatty\\\"):\\n+ return False\\n+ return sys.stdout.isatty()\\n+\\n+ def _c(self, code: str, text: str) -> str:\\n+ \\\"\\\"\\\"Apply color code if colors are supported.\\\"\\\"\\\"\\n+ if not self._color:\\n+ return text\\n+ return f\\\"{code}{text}{_RESET}\\\"\\n+\\n+ # ── Banner ────────────────────────────────────────────────────────\\n+\\n+ def print_banner(self):\\n+ \\\"\\\"\\\"Print the startup banner with branding.\\\"\\\"\\\"\\n+ import textwrap\\n+\\n+ inner = 72\\n+\\n+ def _box_line(content: str) -> str:\\n+ \\\"\\\"\\\"Wrap content in box drawing, padding to inner width.\\\"\\\"\\\"\\n+ pad = inner - _visible_len(content)\\n+ vl = self._c(_DARK_GRAY, _V_LINE)\\n+ return f\\\"{vl}{content}{' ' * max(0, pad)}{vl}\\\"\\n+\\n+ def _meta_lines(label: str, value: str) -> list[str]:\\n+ \\\"\\\"\\\"Wrap a metadata line for the banner box.\\\"\\\"\\\"\\n+ icon = self._c(_MAGENTA, \\\"◇\\\")\\n+ label_text = self._c(_DARK_GRAY, label)\\n+ prefix = f\\\" {icon} {label_text} \\\"\\n+ available = max(12, inner - _visible_len(prefix))\\n+ wrapped = textwrap.wrap(\\n+ value,\\n+ width=available,\\n+ break_long_words=True,\\n+ break_on_hyphens=False,\\n+ ) or [\\\"\\\"]\\n+ lines = [f\\\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\\\"]\\n+ continuation_prefix = \\\" \\\" * _visible_len(prefix)\\n+ for chunk in wrapped[1:]:\\n+ lines.append(f\\\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\\\")\\n+ return lines\\n+\\n+ top = self._c(_DARK_GRAY, f\\\"{_TL}{_H_LINE * inner}{_TR}\\\")\\n+ bot = self._c(_DARK_GRAY, f\\\"{_BL}{_H_LINE * inner}{_BR}\\\")\\n+\\n+ # Title: ◆ cli-anything · Shotcut\\n+ icon = self._c(_CYAN + _BOLD, \\\"◆\\\")\\n+ brand = self._c(_CYAN + _BOLD, \\\"cli-anything\\\")\\n+ dot = self._c(_DARK_GRAY, \\\"·\\\")\\n+ name = self._c(self.accent + _BOLD, self.display_name)\\n+ title = f\\\" {icon} {brand} {dot} {name}\\\"\\n+\\n+ ver = f\\\" {self._c(_DARK_GRAY, f' v{self.version}')}\\\"\\n+ tip = f\\\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\\\"\\n+ empty = \\\"\\\"\\n+\\n+ meta_lines: list[str] = []\\n+ meta_lines.extend(_meta_lines(\\\"Install:\\\", self.skill_install_cmd))\\n+ meta_lines.extend(_meta_lines(\\\"Global skill:\\\", _display_home_path(self.global_skill_path)))\\n+ print(top)\\n+ print(_box_line(title))\\n+ print(_box_line(ver))\\n+ for line in meta_lines:\\n+ print(_box_line(line))\\n+ print(_box_line(empty))\\n+ print(_box_line(tip))\\n+ print(bot)\\n+ print()\\n+\\n+ # ── Prompt ────────────────────────────────────────────────────────\\n+\\n+ def prompt(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a styled prompt string for prompt_toolkit or input().\\n+\\n+ Args:\\n+ project_name: Current project name (empty if none open).\\n+ modified: Whether the project has unsaved changes.\\n+ context: Optional extra context to show in prompt.\\n+\\n+ Returns:\\n+ Formatted prompt string.\\n+ \\\"\\\"\\\"\\n+ parts = []\\n+\\n+ # Icon\\n+ if self._color:\\n+ parts.append(f\\\"{_CYAN}◆{_RESET} \\\")\\n+ else:\\n+ parts.append(\\\"> \\\")\\n+\\n+ # Software name\\n+ parts.append(self._c(self.accent + _BOLD, self.software))\\n+\\n+ # Project context\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ parts.append(f\\\" {self._c(_DARK_GRAY, '[')}\\\")\\n+ parts.append(self._c(_LIGHT_GRAY, f\\\"{ctx}{mod}\\\"))\\n+ parts.append(self._c(_DARK_GRAY, ']'))\\n+\\n+ parts.append(self._c(_GRAY, \\\" ❯ \\\"))\\n+\\n+ return \\\"\\\".join(parts)\\n+\\n+ def prompt_tokens(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Build prompt_toolkit formatted text tokens for the prompt.\\n+\\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\\n+\\n+ Returns:\\n+ list of (style, text) tuples for prompt_toolkit.\\n+ \\\"\\\"\\\"\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+ tokens = []\\n+\\n+ tokens.append((\\\"class:icon\\\", \\\"◆ \\\"))\\n+ tokens.append((\\\"class:software\\\", self.software))\\n+\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ tokens.append((\\\"class:bracket\\\", \\\" [\\\"))\\n+ tokens.append((\\\"class:context\\\", f\\\"{ctx}{mod}\\\"))\\n+ tokens.append((\\\"class:bracket\\\", \\\"]\\\"))\\n+\\n+ tokens.append((\\\"class:arrow\\\", \\\" ❯ \\\"))\\n+\\n+ return tokens\\n+\\n+ def get_prompt_style(self):\\n+ \\\"\\\"\\\"Get a prompt_toolkit Style object matching the skin.\\n+\\n+ Returns:\\n+ prompt_toolkit.styles.Style\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit.styles import Style\\n+ except ImportError:\\n+ return None\\n+\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+\\n+ return Style.from_dict({\\n+ \\\"icon\\\": \\\"#5fdfdf bold\\\", # cyan brand color\\n+ \\\"software\\\": f\\\"{accent_hex} bold\\\",\\n+ \\\"bracket\\\": \\\"#585858\\\",\\n+ \\\"context\\\": \\\"#bcbcbc\\\",\\n+ \\\"arrow\\\": \\\"#808080\\\",\\n+ # Completion menu\\n+ \\\"completion-menu.completion\\\": \\\"bg:#303030 #bcbcbc\\\",\\n+ \\\"completion-menu.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ \\\"completion-menu.meta.completion\\\": \\\"bg:#303030 #808080\\\",\\n+ \\\"completion-menu.meta.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ # Auto-suggest\\n+ \\\"auto-suggest\\\": \\\"#585858\\\",\\n+ # Bottom toolbar\\n+ \\\"bottom-toolbar\\\": \\\"bg:#1c1c1c #808080\\\",\\n+ \\\"bottom-toolbar.text\\\": \\\"#808080\\\",\\n+ })\\n+\\n+ # ── Messages ──────────────────────────────────────────────────────\\n+\\n+ def success(self, message: str):\\n+ \\\"\\\"\\\"Print a success message with green checkmark.\\\"\\\"\\\"\\n+ icon = self._c(_GREEN + _BOLD, \\\"✓\\\")\\n+ print(f\\\" {icon} {self._c(_GREEN, message)}\\\")\\n+\\n+ def error(self, message: str):\\n+ \\\"\\\"\\\"Print an error message with red cross.\\\"\\\"\\\"\\n+ icon = self._c(_RED + _BOLD, \\\"✗\\\")\\n+ print(f\\\" {icon} {self._c(_RED, message)}\\\", file=sys.stderr)\\n+\\n+ def warning(self, message: str):\\n+ \\\"\\\"\\\"Print a warning message with yellow triangle.\\\"\\\"\\\"\\n+ icon = self._c(_YELLOW + _BOLD, \\\"⚠\\\")\\n+ print(f\\\" {icon} {self._c(_YELLOW, message)}\\\")\\n+\\n+ def info(self, message: str):\\n+ \\\"\\\"\\\"Print an info message with blue dot.\\\"\\\"\\\"\\n+ icon = self._c(_BLUE, \\\"●\\\")\\n+ print(f\\\" {icon} {self._c(_LIGHT_GRAY, message)}\\\")\\n+\\n+ def hint(self, message: str):\\n+ \\\"\\\"\\\"Print a subtle hint message.\\\"\\\"\\\"\\n+ print(f\\\" {self._c(_DARK_GRAY, message)}\\\")\\n+\\n+ def section(self, title: str):\\n+ \\\"\\\"\\\"Print a section header.\\\"\\\"\\\"\\n+ print()\\n+ print(f\\\" {self._c(self.accent + _BOLD, title)}\\\")\\n+ print(f\\\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\\\")\\n+\\n+ # ── Status display ────────────────────────────────────────────────\\n+\\n+ def status(self, label: str, value: str):\\n+ \\\"\\\"\\\"Print a key-value status line.\\\"\\\"\\\"\\n+ lbl = self._c(_GRAY, f\\\" {label}:\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def status_block(self, items: dict[str, str], title: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a block of status key-value pairs.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs.\\n+ title: Optional title for the block.\\n+ \\\"\\\"\\\"\\n+ if title:\\n+ self.section(title)\\n+\\n+ max_key = max(len(k) for k in items) if items else 0\\n+ for label, value in items.items():\\n+ lbl = self._c(_GRAY, f\\\" {label:<{max_key}}\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def progress(self, current: int, total: int, label: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a simple progress indicator.\\n+\\n+ Args:\\n+ current: Current step number.\\n+ total: Total number of steps.\\n+ label: Optional label for the progress.\\n+ \\\"\\\"\\\"\\n+ pct = int(current / total * 100) if total > 0 else 0\\n+ bar_width = 20\\n+ filled = int(bar_width * current / total) if total > 0 else 0\\n+ bar = \\\"█\\\" * filled + \\\"░\\\" * (bar_width - filled)\\n+ text = f\\\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\\\"\\n+ if label:\\n+ text += f\\\" {self._c(_LIGHT_GRAY, label)}\\\"\\n+ print(text)\\n+\\n+ # ── Table display ─────────────────────────────────────────────────\\n+\\n+ def table(self, headers: list[str], rows: list[list[str]],\\n+ max_col_width: int = 40):\\n+ \\\"\\\"\\\"Print a formatted table with box-drawing characters.\\n+\\n+ Args:\\n+ headers: Column header strings.\\n+ rows: List of rows, each a list of cell strings.\\n+ max_col_width: Maximum column width before truncation.\\n+ \\\"\\\"\\\"\\n+ if not headers:\\n+ return\\n+\\n+ # Calculate column widths\\n+ col_widths = [min(len(h), max_col_width) for h in headers]\\n+ for row in rows:\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ col_widths[i] = min(\\n+ max(col_widths[i], len(str(cell))), max_col_width\\n+ )\\n+\\n+ def pad(text: str, width: int) -> str:\\n+ t = str(text)[:width]\\n+ return t + \\\" \\\" * (width - len(t))\\n+\\n+ # Header\\n+ header_cells = [\\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\\n+ for i, h in enumerate(headers)\\n+ ]\\n+ sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ header_line = f\\\" {sep.join(header_cells)}\\\"\\n+ print(header_line)\\n+\\n+ # Separator\\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\\n+ sep_line = self._c(_DARK_GRAY, f\\\" {'───'.join([_H_LINE * w for w in col_widths])}\\\")\\n+ print(sep_line)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\nnew file mode 100644\\nindex 000000000..3296206c8\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\n@@ -0,0 +1,568 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ display_overrides = {\\\"wavetone\\\": \\\"WaveTone\\\"}\\n+ self.display_name = display_overrides.get(self.software, software.replace(\\\"_\\\", \\\" \\\").title())\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\\n+\\n+ # History file\\n+ if history_file is None:\\n+ hist_dir = Path.home() / f\\\".cli-anything-{self.software}\\\"\\n+ hist_dir.mkdir(parents=True, exist_ok=True)\\n+ self.history_file = str(hist_dir / \\\"history\\\")\\n+ else:\\n+ self.history_file = history_file\\n+\\n+ # Detect terminal capabilities\\n+ self._color = self._detect_color_support()\\n+\\n+ def _detect_color_support(self) -> bool:\\n+ \\\"\\\"\\\"Check if terminal supports color.\\\"\\\"\\\"\\n+ if os.environ.get(\\\"NO_COLOR\\\"):\\n+ return False\\n+ if os.environ.get(\\\"CLI_ANYTHING_NO_COLOR\\\"):\\n+ return False\\n+ if not hasattr(sys.stdout, \\\"isatty\\\"):\\n+ return False\\n+ return sys.stdout.isatty()\\n+\\n+ def _c(self, code: str, text: str) -> str:\\n+ \\\"\\\"\\\"Apply color code if colors are supported.\\\"\\\"\\\"\\n+ if not self._color:\\n+ return text\\n+ return f\\\"{code}{text}{_RESET}\\\"\\n+\\n+ # ── Banner ────────────────────────────────────────────────────────\\n+\\n+ def print_banner(self):\\n+ \\\"\\\"\\\"Print the startup banner with branding.\\\"\\\"\\\"\\n+ import textwrap\\n+\\n+ inner = 72\\n+\\n+ def _box_line(content: str) -> str:\\n+ \\\"\\\"\\\"Wrap content in box drawing, padding to inner width.\\\"\\\"\\\"\\n+ pad = inner - _visible_len(content)\\n+ vl = self._c(_DARK_GRAY, _V_LINE)\\n+ return f\\\"{vl}{content}{' ' * max(0, pad)}{vl}\\\"\\n+\\n+ def _meta_lines(label: str, value: str) -> list[str]:\\n+ \\\"\\\"\\\"Wrap a metadata line for the banner box.\\\"\\\"\\\"\\n+ icon = self._c(_MAGENTA, \\\"◇\\\")\\n+ label_text = self._c(_DARK_GRAY, label)\\n+ prefix = f\\\" {icon} {label_text} \\\"\\n+ available = max(12, inner - _visible_len(prefix))\\n+ wrapped = textwrap.wrap(\\n+ value,\\n+ width=available,\\n+ break_long_words=True,\\n+ break_on_hyphens=False,\\n+ ) or [\\\"\\\"]\\n+ lines = [f\\\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\\\"]\\n+ continuation_prefix = \\\" \\\" * _visible_len(prefix)\\n+ for chunk in wrapped[1:]:\\n+ lines.append(f\\\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\\\")\\n+ return lines\\n+\\n+ top = self._c(_DARK_GRAY, f\\\"{_TL}{_H_LINE * inner}{_TR}\\\")\\n+ bot = self._c(_DARK_GRAY, f\\\"{_BL}{_H_LINE * inner}{_BR}\\\")\\n+\\n+ # Title: ◆ cli-anything · Shotcut\\n+ icon = self._c(_CYAN + _BOLD, \\\"◆\\\")\\n+ brand = self._c(_CYAN + _BOLD, \\\"cli-anything\\\")\\n+ dot = self._c(_DARK_GRAY, \\\"·\\\")\\n+ name = self._c(self.accent + _BOLD, self.display_name)\\n+ title = f\\\" {icon} {brand} {dot} {name}\\\"\\n+\\n+ ver = f\\\" {self._c(_DARK_GRAY, f' v{self.version}')}\\\"\\n+ tip = f\\\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\\\"\\n+ empty = \\\"\\\"\\n+\\n+ meta_lines: list[str] = []\\n+ meta_lines.extend(_meta_lines(\\\"Install:\\\", self.skill_install_cmd))\\n+ if self.skill_path:\\n+ meta_lines.extend(_meta_lines(\\\"Local skill:\\\", _display_home_path(self.skill_path)))\\n+ meta_lines.extend(_meta_lines(\\\"Global skill:\\\", _display_home_path(self.global_skill_path)))\\n+ print(top)\\n+ print(_box_line(title))\\n+ print(_box_line(ver))\\n+ for line in meta_lines:\\n+ print(_box_line(line))\\n+ print(_box_line(empty))\\n+ print(_box_line(tip))\\n+ print(bot)\\n+ print()\\n+\\n+ # ── Prompt ────────────────────────────────────────────────────────\\n+\\n+ def prompt(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a styled prompt string for prompt_toolkit or input().\\n+\\n+ Args:\\n+ project_name: Current project name (empty if none open).\\n+ modified: Whether the project has unsaved changes.\\n+ context: Optional extra context to show in prompt.\\n+\\n+ Returns:\\n+ Formatted prompt string.\\n+ \\\"\\\"\\\"\\n+ parts = []\\n+\\n+ # Icon\\n+ if self._color:\\n+ parts.append(f\\\"{_CYAN}◆{_RESET} \\\")\\n+ else:\\n+ parts.append(\\\"> \\\")\\n+\\n+ # Software name\\n+ parts.append(self._c(self.accent + _BOLD, self.software))\\n+\\n+ # Project context\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ parts.append(f\\\" {self._c(_DARK_GRAY, '[')}\\\")\\n+ parts.append(self._c(_LIGHT_GRAY, f\\\"{ctx}{mod}\\\"))\\n+ parts.append(self._c(_DARK_GRAY, ']'))\\n+\\n+ parts.append(self._c(_GRAY, \\\" ❯ \\\"))\\n+\\n+ return \\\"\\\".join(parts)\\n+\\n+ def prompt_tokens(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Build prompt_toolkit formatted text tokens for the prompt.\\n+\\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\\n+\\n+ Returns:\\n+ list of (style, text) tuples for prompt_toolkit.\\n+ \\\"\\\"\\\"\\n+ tokens = []\\n+\\n+ tokens.append((\\\"class:icon\\\", \\\"◆ \\\"))\\n+ tokens.append((\\\"class:software\\\", self.software))\\n+\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ tokens.append((\\\"class:bracket\\\", \\\" [\\\"))\\n+ tokens.append((\\\"class:context\\\", f\\\"{ctx}{mod}\\\"))\\n+ tokens.append((\\\"class:bracket\\\", \\\"]\\\"))\\n+\\n+ tokens.append((\\\"class:arrow\\\", \\\" ❯ \\\"))\\n+\\n+ return tokens\\n+\\n+ def get_prompt_style(self):\\n+ \\\"\\\"\\\"Get a prompt_toolkit Style object matching the skin.\\n+\\n+ Returns:\\n+ prompt_toolkit.styles.Style\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit.styles import Style\\n+ except ImportError:\\n+ return None\\n+\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+\\n+ return Style.from_dict({\\n+ \\\"icon\\\": \\\"#5fdfdf bold\\\", # cyan brand color\\n+ \\\"software\\\": f\\\"{accent_hex} bold\\\",\\n+ \\\"bracket\\\": \\\"#585858\\\",\\n+ \\\"context\\\": \\\"#bcbcbc\\\",\\n+ \\\"arrow\\\": \\\"#808080\\\",\\n+ # Completion menu\\n+ \\\"completion-menu.completion\\\": \\\"bg:#303030 #bcbcbc\\\",\\n+ \\\"completion-menu.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ \\\"completion-menu.meta.completion\\\": \\\"bg:#303030 #808080\\\",\\n+ \\\"completion-menu.meta.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ # Auto-suggest\\n+ \\\"auto-suggest\\\": \\\"#585858\\\",\\n+ # Bottom toolbar\\n+ \\\"bottom-toolbar\\\": \\\"bg:#1c1c1c #808080\\\",\\n+ \\\"bottom-toolbar.text\\\": \\\"#808080\\\",\\n+ })\\n+\\n+ # ── Messages ──────────────────────────────────────────────────────\\n+\\n+ def success(self, message: str):\\n+ \\\"\\\"\\\"Print a success message with green checkmark.\\\"\\\"\\\"\\n+ icon = self._c(_GREEN + _BOLD, \\\"✓\\\")\\n+ print(f\\\" {icon} {self._c(_GREEN, message)}\\\")\\n+\\n+ def error(self, message: str):\\n+ \\\"\\\"\\\"Print an error message with red cross.\\\"\\\"\\\"\\n+ icon = self._c(_RED + _BOLD, \\\"✗\\\")\\n+ print(f\\\" {icon} {self._c(_RED, message)}\\\", file=sys.stderr)\\n+\\n+ def warning(self, message: str):\\n+ \\\"\\\"\\\"Print a warning message with yellow triangle.\\\"\\\"\\\"\\n+ icon = self._c(_YELLOW + _BOLD, \\\"⚠\\\")\\n+ print(f\\\" {icon} {self._c(_YELLOW, message)}\\\")\\n+\\n+ def info(self, message: str):\\n+ \\\"\\\"\\\"Print an info message with blue dot.\\\"\\\"\\\"\\n+ icon = self._c(_BLUE, \\\"●\\\")\\n+ print(f\\\" {icon} {self._c(_LIGHT_GRAY, message)}\\\")\\n+\\n+ def hint(self, message: str):\\n+ \\\"\\\"\\\"Print a subtle hint message.\\\"\\\"\\\"\\n+ print(f\\\" {self._c(_DARK_GRAY, message)}\\\")\\n+\\n+ def section(self, title: str):\\n+ \\\"\\\"\\\"Print a section header.\\\"\\\"\\\"\\n+ print()\\n+ print(f\\\" {self._c(self.accent + _BOLD, title)}\\\")\\n+ print(f\\\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\\\")\\n+\\n+ # ── Status display ────────────────────────────────────────────────\\n+\\n+ def status(self, label: str, value: str):\\n+ \\\"\\\"\\\"Print a key-value status line.\\\"\\\"\\\"\\n+ lbl = self._c(_GRAY, f\\\" {label}:\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def status_block(self, items: dict[str, str], title: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a block of status key-value pairs.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs.\\n+ title: Optional title for the block.\\n+ \\\"\\\"\\\"\\n+ if title:\\n+ self.section(title)\\n+\\n+ max_key = max(len(k) for k in items) if items else 0\\n+ for label, value in items.items():\\n+ lbl = self._c(_GRAY, f\\\" {label:<{max_key}}\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def progress(self, current: int, total: int, label: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a simple progress indicator.\\n+\\n+ Args:\\n+ current: Current step number.\\n+ total: Total number of steps.\\n+ label: Optional label for the progress.\\n+ \\\"\\\"\\\"\\n+ pct = int(current / total * 100) if total > 0 else 0\\n+ bar_width = 20\\n+ filled = int(bar_width * current / total) if total > 0 else 0\\n+ bar = \\\"█\\\" * filled + \\\"░\\\" * (bar_width - filled)\\n+ text = f\\\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\\\"\\n+ if label:\\n+ text += f\\\" {self._c(_LIGHT_GRAY, label)}\\\"\\n+ print(text)\\n+\\n+ # ── Table display ─────────────────────────────────────────────────\\n+\\n+ def table(self, headers: list[str], rows: list[list[str]],\\n+ max_col_width: int = 40):\\n+ \\\"\\\"\\\"Print a formatted table with box-drawing characters.\\n+\\n+ Args:\\n+ headers: Column header strings.\\n+ rows: List of rows, each a list of cell strings.\\n+ max_col_width: Maximum column width before truncation.\\n+ \\\"\\\"\\\"\\n+ if not headers:\\n+ return\\n+\\n+ # Calculate column widths\\n+ col_widths = [min(len(h), max_col_width) for h in headers]\\n+ for row in rows:\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ col_widths[i] = min(\\n+ max(col_widths[i], len(str(cell))), max_col_width\\n+ )\\n+\\n+ def pad(text: str, width: int) -> str:\\n+ t = str(text)[:width]\\n+ return t + \\\" \\\" * (width - len(t))\\n+\\n+ # Header\\n+ header_cells = [\\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\\n+ for i, h in enumerate(headers)\\n+ ]\\n+ sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ header_line = f\\\" {sep.join(header_cells)}\\\"\\n+ print(header_line)\\n+\\n+ # Separator\\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\\n+ sep_line = f\\\" {sep.join(sep_parts)}\\\"\\n+ print(sep_line)\\n+\\n+ # Rows\\n+ for row in rows:\\n+ cells = []\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\\n+ row_sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ print(f\\\" {row_sep.join(cells)}\\\")\\n+\\n+ # ── Help display ──────────────────────────────────────────────────\\n+\\n+ def help(self, commands: dict[str, str]):\\n+ \\\"\\\"\\\"Print a formatted help listing.\\n+\\n+ Args:\\n+ commands: Dict of command -> description pairs.\\n+ \\\"\\\"\\\"\\n+ self.section(\\\"Commands\\\")\\n+ max_cmd = max(len(c) for c in commands) if commands else 0\\n+ for cmd, desc in commands.items():\\n+ cmd_styled = self._c(self.accent, f\\\" {cmd:<{max_cmd}}\\\")\\n+ desc_styled = self._c(_GRAY, f\\\" {desc}\\\")\\n+ print(f\\\"{cmd_styled}{desc_styled}\\\")\\n+ print()\\n+\\n+ # ── Goodbye ───────────────────────────────────────────────────────\\n+\\n+ def print_goodbye(self):\\n+ \\\"\\\"\\\"Print a styled goodbye message.\\\"\\\"\\\"\\n+ print(f\\\"\\\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\\\n\\\")\\n+\\n+ # ── Prompt toolkit session factory ────────────────────────────────\\n+\\n+ def create_prompt_session(self):\\n+ \\\"\\\"\\\"Create a prompt_toolkit PromptSession with skin styling.\\n+\\n+ Returns:\\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit import PromptSession\\n+ from prompt_toolkit.history import FileHistory\\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\\n+\\n+ style = self.get_prompt_style()\\n+\\n+ session = PromptSession(\\n+ history=FileHistory(self.history_file),\\n+ auto_suggest=AutoSuggestFromHistory(),\\n+ style=style,\\n+ enable_history_search=True,\\n+ )\\n+ return session\\n+ except ImportError:\\n+ return None\\n+\\n+ def get_input(self, pt_session, project_name: str = \\\"\\\",\\n+ modified: bool = False, context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Get input from user using prompt_toolkit or fallback.\\n+\\n+ Args:\\n+ pt_session: A prompt_toolkit PromptSession (or None).\\n+ project_name: Current project name.\\n+ modified: Whether project has unsaved changes.\\n+ context: Optional context string.\\n+\\n+ Returns:\\n+ User input string (stripped).\\n+ \\\"\\\"\\\"\\n+ if pt_session is not None:\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ tokens = self.prompt_tokens(project_name, modified, context)\\n+ return pt_session.prompt(FormattedText(tokens)).strip()\\n+ else:\\n+ raw_prompt = self.prompt(project_name, modified, context)\\n+ return input(raw_prompt).strip()\\n+\\n+ # ── Toolbar builder ───────────────────────────────────────────────\\n+\\n+ def bottom_toolbar(self, items: dict[str, str]):\\n+ \\\"\\\"\\\"Create a bottom toolbar callback for prompt_toolkit.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs to show in toolbar.\\n+\\n+ Returns:\\n+ A callable that returns FormattedText for the toolbar.\\n+ \\\"\\\"\\\"\\n+ def toolbar():\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ parts = []\\n+ for i, (k, v) in enumerate(items.items()):\\n+ if i > 0:\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", \\\" │ \\\"))\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", f\\\" {k}: \\\"))\\n+ parts.append((\\\"class:bottom-toolbar\\\", v))\\n+ return FormattedText(parts)\\n+ return toolbar\\n+\\n+\\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\\n+\\n+_ANSI_256_TO_HEX = {\\n+ \\\"\\\\033[38;5;33m\\\": \\\"#0087ff\\\", # audacity navy blue\\n+ \\\"\\\\033[38;5;35m\\\": \\\"#00af5f\\\", # shotcut teal\\n+ \\\"\\\\033[38;5;39m\\\": \\\"#00afff\\\", # inkscape bright blue\\n+ \\\"\\\\033[38;5;40m\\\": \\\"#00d700\\\", # libreoffice green\\n+ \\\"\\\\033[38;5;55m\\\": \\\"#5f00af\\\", # obs purple\\n+ \\\"\\\\033[38;5;69m\\\": \\\"#5f87ff\\\", # kdenlive slate blue\\n+ \\\"\\\\033[38;5;75m\\\": \\\"#5fafff\\\", # default sky blue\\n+ \\\"\\\\033[38;5;80m\\\": \\\"#5fd7d7\\\", # brand cyan\\n+ \\\"\\\\033[38;5;208m\\\": \\\"#ff8700\\\", # blender deep orange\\n+ \\\"\\\\033[38;5;214m\\\": \\\"#ffaf00\\\", # gimp warm orange\\n+}\\n\"\n },\n {\n \"comment\": \"`process.poll()` is called twice back-to-back, which can make `running_after_wait` and `exit_code` slightly inconsistent if the process exits between calls. Store the poll result once (e.g., `polled = process.poll()`) and derive both fields from it for clearer, deterministic reporting.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\",\n \"hunk\": \"@@ -0,0 +1,159 @@\\n+\\\"\\\"\\\"Backend wrapper for the real WaveTone 2.61 executable.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import os\\n+import platform\\n+import subprocess\\n+import time\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\\n+\\n+\\n+REQUIRED_DATA_FILES = [\\n+ \\\"awlib.dll\\\",\\n+ \\\"bass.dll\\\",\\n+ \\\"bassflac.dll\\\",\\n+ \\\"basswma.dll\\\",\\n+ \\\"basswv.dll\\\",\\n+ \\\"bass_aac.dll\\\",\\n+ \\\"bass_alac.dll\\\",\\n+ \\\"bass_ape.dll\\\",\\n+ \\\"bass_tta.dll\\\",\\n+ \\\"asdecoder.exe\\\",\\n+]\\n+\\n+\\n+def default_candidates() -> list[Path]:\\n+ candidates: list[Path] = []\\n+ env_exe = os.environ.get(\\\"WAVETONE_EXE\\\")\\n+ if env_exe:\\n+ candidates.append(Path(env_exe))\\n+ env_home = os.environ.get(\\\"WAVETONE_HOME\\\")\\n+ if env_home:\\n+ candidates.append(Path(env_home) / \\\"wavetone.exe\\\")\\n+ candidates.append(Path(env_home) / \\\"WaveTone.exe\\\")\\n+ home = Path.home()\\n+ candidates.extend(\\n+ [\\n+ home / \\\"Desktop\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ home / \\\"Downloads\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ Path(\\\"C:/Program Files/WaveTone/wavetone.exe\\\"),\\n+ Path(\\\"C:/Program Files (x86)/WaveTone/wavetone.exe\\\"),\\n+ ]\\n+ )\\n+ return candidates\\n+\\n+\\n+def find_wavetone(executable: str | Path | None = None) -> Path:\\n+ candidates = [Path(executable)] if executable else default_candidates()\\n+ checked: list[str] = []\\n+ for candidate in candidates:\\n+ path = candidate.expanduser()\\n+ checked.append(str(path))\\n+ if path.exists() and path.is_file():\\n+ return path.resolve()\\n+ raise FileNotFoundError(\\n+ \\\"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \\\"\\n+ \\\"WAVETONE_HOME to the extracted WaveTone directory. Checked: \\\"\\n+ + \\\"; \\\".join(checked)\\n+ )\\n+\\n+\\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\\n+ checks: list[dict[str, Any]] = []\\n+ try:\\n+ exe = find_wavetone(executable)\\n+ root = exe.parent\\n+ checks.append({\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": True, \\\"path\\\": str(exe)})\\n+ except FileNotFoundError as exc:\\n+ return {\\n+ \\\"ready\\\": False,\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"checks\\\": [{\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": False, \\\"error\\\": str(exc)}],\\n+ }\\n+\\n+ data_dir = root / \\\"data\\\"\\n+ checks.append({\\\"name\\\": \\\"data directory\\\", \\\"ok\\\": data_dir.is_dir(), \\\"path\\\": str(data_dir)})\\n+ for filename in REQUIRED_DATA_FILES:\\n+ path = data_dir / filename\\n+ checks.append({\\\"name\\\": f\\\"data/{filename}\\\", \\\"ok\\\": path.exists(), \\\"path\\\": str(path)})\\n+ help_dir = root / \\\"wthelp\\\"\\n+ checks.append({\\\"name\\\": \\\"help directory\\\", \\\"ok\\\": help_dir.is_dir(), \\\"path\\\": str(help_dir)})\\n+ checks.append(\\n+ {\\n+ \\\"name\\\": \\\"windows host\\\",\\n+ \\\"ok\\\": platform.system().lower() == \\\"windows\\\",\\n+ \\\"platform\\\": platform.platform(),\\n+ }\\n+ )\\n+ return {\\n+ \\\"ready\\\": all(check[\\\"ok\\\"] for check in checks),\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"root\\\": str(root),\\n+ \\\"checks\\\": checks,\\n+ }\\n+\\n+\\n+def launch_wavetone(\\n+ audio_path: str | Path | None = None,\\n+ executable: str | Path | None = None,\\n+ wait_seconds: float = 0.0,\\n+ terminate: bool = False,\\n+) -> dict[str, Any]:\\n+ exe = find_wavetone(executable)\\n+ args = [str(exe)]\\n+ audio: Path | None = None\\n+ if audio_path:\\n+ audio = normalize_audio_path(audio_path)\\n+ args.append(str(audio))\\n+\\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\\n+ if wait_seconds > 0:\\n+ time.sleep(wait_seconds)\\n+ running_after_wait = process.poll() is None\\n+ exit_code = process.poll()\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\\nnew file mode 100644\\nindex 000000000..81d3d35ec\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\\n@@ -0,0 +1,163 @@\\n+\\\"\\\"\\\"Backend wrapper for the real WaveTone 2.61 executable.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import os\\n+import platform\\n+import subprocess\\n+import time\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\\n+\\n+\\n+REQUIRED_DATA_FILES = [\\n+ \\\"awlib.dll\\\",\\n+ \\\"bass.dll\\\",\\n+ \\\"bassflac.dll\\\",\\n+ \\\"basswma.dll\\\",\\n+ \\\"basswv.dll\\\",\\n+ \\\"bass_aac.dll\\\",\\n+ \\\"bass_alac.dll\\\",\\n+ \\\"bass_ape.dll\\\",\\n+ \\\"bass_tta.dll\\\",\\n+ \\\"asdecoder.exe\\\",\\n+]\\n+\\n+\\n+def default_candidates() -> list[Path]:\\n+ candidates: list[Path] = []\\n+ env_exe = os.environ.get(\\\"WAVETONE_EXE\\\")\\n+ if env_exe:\\n+ candidates.append(Path(env_exe))\\n+ env_home = os.environ.get(\\\"WAVETONE_HOME\\\")\\n+ if env_home:\\n+ candidates.append(Path(env_home) / \\\"wavetone.exe\\\")\\n+ candidates.append(Path(env_home) / \\\"WaveTone.exe\\\")\\n+ home = Path.home()\\n+ candidates.extend(\\n+ [\\n+ home / \\\"Desktop\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ home / \\\"Downloads\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ Path(\\\"C:/Program Files/WaveTone/wavetone.exe\\\"),\\n+ Path(\\\"C:/Program Files (x86)/WaveTone/wavetone.exe\\\"),\\n+ ]\\n+ )\\n+ return candidates\\n+\\n+\\n+def find_wavetone(executable: str | Path | None = None) -> Path:\\n+ candidates = [Path(executable)] if executable else default_candidates()\\n+ checked: list[str] = []\\n+ for candidate in candidates:\\n+ path = candidate.expanduser()\\n+ checked.append(str(path))\\n+ if path.exists() and path.is_file():\\n+ return path.resolve()\\n+ raise FileNotFoundError(\\n+ \\\"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \\\"\\n+ \\\"WAVETONE_HOME to the extracted WaveTone directory. Checked: \\\"\\n+ + \\\"; \\\".join(checked)\\n+ )\\n+\\n+\\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\\n+ checks: list[dict[str, Any]] = []\\n+ try:\\n+ exe = find_wavetone(executable)\\n+ root = exe.parent\\n+ checks.append({\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": True, \\\"path\\\": str(exe)})\\n+ except FileNotFoundError as exc:\\n+ return {\\n+ \\\"ready\\\": False,\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"checks\\\": [{\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": False, \\\"error\\\": str(exc)}],\\n+ }\\n+\\n+ data_dir = root / \\\"data\\\"\\n+ checks.append({\\\"name\\\": \\\"data directory\\\", \\\"ok\\\": data_dir.is_dir(), \\\"path\\\": str(data_dir)})\\n+ for filename in REQUIRED_DATA_FILES:\\n+ path = data_dir / filename\\n+ checks.append({\\\"name\\\": f\\\"data/{filename}\\\", \\\"ok\\\": path.is_file(), \\\"path\\\": str(path)})\\n+ help_dir = root / \\\"wthelp\\\"\\n+ checks.append({\\\"name\\\": \\\"help directory\\\", \\\"ok\\\": help_dir.is_dir(), \\\"path\\\": str(help_dir)})\\n+ checks.append(\\n+ {\\n+ \\\"name\\\": \\\"windows host\\\",\\n+ \\\"ok\\\": platform.system().lower() == \\\"windows\\\",\\n+ \\\"platform\\\": platform.platform(),\\n+ }\\n+ )\\n+ return {\\n+ \\\"ready\\\": all(check[\\\"ok\\\"] for check in checks),\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"root\\\": str(root),\\n+ \\\"checks\\\": checks,\\n+ }\\n+\\n+\\n+def launch_wavetone(\\n+ audio_path: str | Path | None = None,\\n+ executable: str | Path | None = None,\\n+ wait_seconds: float = 0.0,\\n+ terminate: bool = False,\\n+) -> dict[str, Any]:\\n+ if platform.system().lower() != \\\"windows\\\":\\n+ raise RuntimeError(\\\"WaveTone launch requires Windows\\\")\\n+\\n+ exe = find_wavetone(executable)\\n+ args = [str(exe)]\\n+ audio: Path | None = None\\n+ if audio_path:\\n+ audio = normalize_audio_path(audio_path)\\n+ args.append(str(audio))\\n+\\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\\n+ if wait_seconds > 0:\\n+ time.sleep(wait_seconds)\\n+ polled = process.poll()\\n+ running_after_wait = polled is None\\n+ exit_code = polled\\n+ terminated = False\\n+ if terminate and running_after_wait:\\n+ process.terminate()\\n+ try:\\n+ process.wait(timeout=3)\\n+ except subprocess.TimeoutExpired:\\n+ process.kill()\\n+ process.wait(timeout=3)\\n+ terminated = True\\n+ exit_code = process.returncode\\n+\\n+ return {\\n+ \\\"backend\\\": \\\"wavetone.exe\\\",\\n+ \\\"executable\\\": str(exe),\\n+ \\\"cwd\\\": str(exe.parent),\\n+ \\\"pid\\\": process.pid,\\n+ \\\"args\\\": args,\\n+ \\\"audio_path\\\": str(audio) if audio else None,\\n+ \\\"running_after_wait\\\": running_after_wait,\\n+ \\\"terminated\\\": terminated,\\n+ \\\"exit_code\\\": exit_code,\\n+ \\\"note\\\": \\\"WaveTone analysis and export dialogs are GUI driven in version 2.61.\\\",\\n+ }\\n+\\n+\\n+def supported_formats() -> dict[str, Any]:\\n+ return {\\n+ \\\"extensions\\\": sorted(SUPPORTED_AUDIO_EXTENSIONS),\\n+ \\\"from_readme\\\": [\\n+ \\\"WAVE\\\",\\n+ \\\"AIFF\\\",\\n+ \\\"MP3\\\",\\n+ \\\"WMA\\\",\\n+ \\\"AAC\\\",\\n+ \\\"Vorbis\\\",\\n+ \\\"FLAC\\\",\\n+ \\\"WavPack\\\",\\n+ \\\"Monkey's Audio\\\",\\n+ \\\"ALAC\\\",\\n+ \\\"TTA\\\",\\n+ ],\\n+ }\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Skip real-backend tests when WaveTone is absent**\\n\\nIn environments without a Windows WaveTone 2.61 install, the default test run now fails because this test invokes `wavetone doctor` with `check=True`, and the same class also calls `find_wavetone()` directly below. I verified this by running `python -m pytest -q` from `wavetone/agent-harness` on Linux, where the suite fails with `WaveTone executable not found`; the README notes these full E2E tests require Windows and an extracted WaveTone install, so they should be gated with a skip marker/env check rather than included unconditionally in the default pytest collection.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\",\n \"hunk\": \"@@ -0,0 +1,118 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+import os\\n+import shutil\\n+import struct\\n+import subprocess\\n+import sys\\n+import wave\\n+from pathlib import Path\\n+\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+\\n+def make_wav(path: Path, freq: float = 440.0, duration: float = 0.5, sample_rate: int = 8000) -> Path:\\n+ frames = int(duration * sample_rate)\\n+ with wave.open(str(path), \\\"wb\\\") as handle:\\n+ handle.setnchannels(1)\\n+ handle.setsampwidth(2)\\n+ handle.setframerate(sample_rate)\\n+ for idx in range(frames):\\n+ sample = int(16000 * math.sin(2 * math.pi * freq * idx / sample_rate))\\n+ handle.writeframes(struct.pack(\\\"<h\\\", sample))\\n+ return path\\n+\\n+\\n+def _resolve_cli(name: str) -> list[str]:\\n+ \\\"\\\"\\\"Resolve installed CLI command; fall back to python -m for development.\\\"\\\"\\\"\\n+ force = os.environ.get(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"\\\").strip() == \\\"1\\\"\\n+ path = shutil.which(name)\\n+ if path:\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+ if force:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ print(f\\\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+\\n+class TestCLISubprocess:\\n+ CLI_BASE = _resolve_cli(\\\"cli-anything-wavetone\\\")\\n+\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_help(self) -> None:\\n+ result = self._run([\\\"--help\\\"])\\n+ assert \\\"Agent-native CLI harness for WaveTone\\\" in result.stdout\\n+\\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\\n+ wav = make_wav(tmp_path / \\\"tone.wav\\\")\\n+ project = tmp_path / \\\"tone.wt.json\\\"\\n+\\n+ result = self._run([\\\"--json\\\", \\\"project\\\", \\\"new\\\", str(wav), \\\"-o\\\", str(project)])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ok\\\"] is True\\n+ assert project.exists()\\n+\\n+ result = self._run(\\n+ [\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"set-tempo\\\", \\\"--bpm\\\", \\\"132.5\\\", \\\"--first-bar\\\", \\\"0.1\\\"]\\n+ )\\n+ assert json.loads(result.stdout)[\\\"tempo\\\"][\\\"bpm\\\"] == 132.5\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"add-label\\\", \\\"intro\\\", \\\"--time\\\", \\\"0.25\\\"])\\n+ assert json.loads(result.stdout)[\\\"labels\\\"][0][\\\"name\\\"] == \\\"intro\\\"\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"audio\\\", \\\"probe\\\"])\\n+ audio = json.loads(result.stdout)[\\\"audio\\\"]\\n+ assert audio[\\\"duration_seconds\\\"] == 0.5\\n+ assert audio[\\\"channels\\\"] == 1\\n+ print(f\\\"\\\\n Project: {project}\\\")\\n+ print(f\\\" Audio: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n+\\n+ def test_formats_json(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"formats\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert \\\".wav\\\" in data[\\\"formats\\\"][\\\"extensions\\\"]\\n+ assert \\\"MP3\\\" in data[\\\"formats\\\"][\\\"from_readme\\\"]\\n+\\n+\\n+class TestRealWaveToneBackend:\\n+ CLI_BASE = _resolve_cli(\\\"cli-anything-wavetone\\\")\\n+\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_doctor_real_backend(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"doctor\\\"])\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\nnew file mode 100644\\nindex 000000000..2ceb45661\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\n@@ -0,0 +1,153 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shutil\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.tests.helpers import make_wav\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+REAL_BACKEND_ENV = \\\"CLI_ANYTHING_WAVETONE_REAL_BACKEND\\\"\\n+\\n+\\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\\n+ \\\"\\\"\\\"Run the in-tree module by default; installed entry points are opt-in.\\\"\\\"\\\"\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ if not force_installed:\\n+ print(f\\\"[_resolve_cli] Using source module: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+ path = shutil.which(name)\\n+ if not path:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+\\n+\\n+def _env_flag_enabled(name: str) -> bool:\\n+ return os.environ.get(name, \\\"\\\").strip().lower() in {\\\"1\\\", \\\"true\\\", \\\"yes\\\", \\\"on\\\"}\\n+\\n+\\n+def _real_backend_ready() -> tuple[bool, str]:\\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\\n+ return False, f\\\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+ if sys.platform != \\\"win32\\\":\\n+ return False, \\\"WaveTone real-backend tests require Windows\\\"\\n+ if not (os.environ.get(\\\"WAVETONE_EXE\\\") or os.environ.get(\\\"WAVETONE_HOME\\\")):\\n+ return False, \\\"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+\\n+ status = wavetone_backend.doctor()\\n+ if status.get(\\\"ready\\\"):\\n+ return True, \\\"\\\"\\n+\\n+ failed_checks = [check[\\\"name\\\"] for check in status.get(\\\"checks\\\", []) if not check.get(\\\"ok\\\")]\\n+ reason = \\\", \\\".join(failed_checks) if failed_checks else \\\"WaveTone backend is not ready\\\"\\n+ return False, f\\\"WaveTone real backend unavailable: {reason}\\\"\\n+\\n+\\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\\n+\\n+\\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_EXE\\\", raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_HOME\\\", raising=False)\\n+\\n+ ready, reason = _real_backend_ready()\\n+\\n+ assert ready is False\\n+ assert REAL_BACKEND_ENV in reason\\n+\\n+\\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setenv(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"1\\\")\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: pytest.fail(\\\"default resolver should not inspect PATH\\\"))\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\") == [sys.executable, \\\"-m\\\", \\\"cli_anything.wavetone.wavetone_cli\\\"]\\n+\\n+\\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: \\\"C:/installed/cli-anything-wavetone.exe\\\")\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\", force_installed=True) == [\\\"C:/installed/cli-anything-wavetone.exe\\\"]\\n+\\n+\\n+class TestCLISubprocess:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_help(self) -> None:\\n+ result = self._run([\\\"--help\\\"])\\n+ assert \\\"Agent-native CLI harness for WaveTone\\\" in result.stdout\\n+\\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\\n+ wav = make_wav(tmp_path / \\\"tone.wav\\\")\\n+ project = tmp_path / \\\"tone.wt.json\\\"\\n+\\n+ result = self._run([\\\"--json\\\", \\\"project\\\", \\\"new\\\", str(wav), \\\"-o\\\", str(project)])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ok\\\"] is True\\n+ assert project.exists()\\n+\\n+ result = self._run(\\n+ [\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"set-tempo\\\", \\\"--bpm\\\", \\\"132.5\\\", \\\"--first-bar\\\", \\\"0.1\\\"]\\n+ )\\n+ assert json.loads(result.stdout)[\\\"tempo\\\"][\\\"bpm\\\"] == 132.5\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"add-label\\\", \\\"intro\\\", \\\"--time\\\", \\\"0.25\\\"])\\n+ assert json.loads(result.stdout)[\\\"labels\\\"][0][\\\"name\\\"] == \\\"intro\\\"\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"audio\\\", \\\"probe\\\"])\\n+ audio = json.loads(result.stdout)[\\\"audio\\\"]\\n+ assert audio[\\\"duration_seconds\\\"] == 0.5\\n+ assert audio[\\\"channels\\\"] == 1\\n+ print(f\\\"\\\\n Project: {project}\\\")\\n+ print(f\\\" Audio: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n+\\n+ def test_formats_json(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"formats\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert \\\".wav\\\" in data[\\\"formats\\\"][\\\"extensions\\\"]\\n+ assert \\\"MP3\\\" in data[\\\"formats\\\"][\\\"from_readme\\\"]\\n+\\n+\\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\\n+class TestRealWaveToneBackend:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_doctor_real_backend(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"doctor\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ready\\\"] is True\\n+ assert any(check[\\\"name\\\"] == \\\"data/asdecoder.exe\\\" and check[\\\"ok\\\"] for check in data[\\\"checks\\\"])\\n+ print(f\\\"\\\\n WaveTone root: {data['root']}\\\")\\n+\\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\\n+ exe = wavetone_backend.find_wavetone()\\n+ wav = make_wav(tmp_path / \\\"launch.wav\\\")\\n+ result = self._run(\\n+ [\\n+ \\\"--json\\\",\\n+ \\\"wavetone\\\",\\n+ \\\"launch\\\",\\n+ str(wav),\\n+ \\\"--exe\\\",\\n+ str(exe),\\n+ \\\"--wait\\\",\\n+ \\\"1\\\",\\n+ \\\"--terminate\\\",\\n+ ]\\n+ )\\n+ data = json.loads(result.stdout)[\\\"launch\\\"]\\n+ assert data[\\\"backend\\\"] == \\\"wavetone.exe\\\"\\n+ assert data[\\\"audio_path\\\"] == str(wav.resolve())\\n+ assert data[\\\"running_after_wait\\\"] is True\\n+ assert data[\\\"terminated\\\"] is True\\n+ print(f\\\"\\\\n Launched WaveTone PID: {data['pid']}\\\")\\n+ print(f\\\" WAV: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Preserve the REPL project context**\\n\\nWhen the REPL is started with `cli-anything-wavetone --project song.wt.json`, every command entered inside the REPL re-enters this group callback without a `--project` option, so `project_path` is `None` and this assignment overwrites the inherited `ctx.obj[\\\"project\\\"]`. Project-scoped commands like `audio probe` then fail with “Project path required” even though the REPL was launched with a project; only update the stored value when an option was explicitly provided, or pass the existing context through unchanged for nested REPL invocations.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,344 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ ctx.obj[\\\"json\\\"] = json_mode\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"`accent_hex` is computed but never used in `prompt_tokens()`. Please either remove it or use it to drive token styling (to keep the method consistent with `get_prompt_style()`).\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\",\n \"hunk\": \"@@ -0,0 +1,567 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ self.display_name = software.replace(\\\"_\\\", \\\" \\\").title()\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\\n+\\n+ # History file\\n+ if history_file is None:\\n+ hist_dir = Path.home() / f\\\".cli-anything-{self.software}\\\"\\n+ hist_dir.mkdir(parents=True, exist_ok=True)\\n+ self.history_file = str(hist_dir / \\\"history\\\")\\n+ else:\\n+ self.history_file = history_file\\n+\\n+ # Detect terminal capabilities\\n+ self._color = self._detect_color_support()\\n+\\n+ def _detect_color_support(self) -> bool:\\n+ \\\"\\\"\\\"Check if terminal supports color.\\\"\\\"\\\"\\n+ if os.environ.get(\\\"NO_COLOR\\\"):\\n+ return False\\n+ if os.environ.get(\\\"CLI_ANYTHING_NO_COLOR\\\"):\\n+ return False\\n+ if not hasattr(sys.stdout, \\\"isatty\\\"):\\n+ return False\\n+ return sys.stdout.isatty()\\n+\\n+ def _c(self, code: str, text: str) -> str:\\n+ \\\"\\\"\\\"Apply color code if colors are supported.\\\"\\\"\\\"\\n+ if not self._color:\\n+ return text\\n+ return f\\\"{code}{text}{_RESET}\\\"\\n+\\n+ # ── Banner ────────────────────────────────────────────────────────\\n+\\n+ def print_banner(self):\\n+ \\\"\\\"\\\"Print the startup banner with branding.\\\"\\\"\\\"\\n+ import textwrap\\n+\\n+ inner = 72\\n+\\n+ def _box_line(content: str) -> str:\\n+ \\\"\\\"\\\"Wrap content in box drawing, padding to inner width.\\\"\\\"\\\"\\n+ pad = inner - _visible_len(content)\\n+ vl = self._c(_DARK_GRAY, _V_LINE)\\n+ return f\\\"{vl}{content}{' ' * max(0, pad)}{vl}\\\"\\n+\\n+ def _meta_lines(label: str, value: str) -> list[str]:\\n+ \\\"\\\"\\\"Wrap a metadata line for the banner box.\\\"\\\"\\\"\\n+ icon = self._c(_MAGENTA, \\\"◇\\\")\\n+ label_text = self._c(_DARK_GRAY, label)\\n+ prefix = f\\\" {icon} {label_text} \\\"\\n+ available = max(12, inner - _visible_len(prefix))\\n+ wrapped = textwrap.wrap(\\n+ value,\\n+ width=available,\\n+ break_long_words=True,\\n+ break_on_hyphens=False,\\n+ ) or [\\\"\\\"]\\n+ lines = [f\\\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\\\"]\\n+ continuation_prefix = \\\" \\\" * _visible_len(prefix)\\n+ for chunk in wrapped[1:]:\\n+ lines.append(f\\\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\\\")\\n+ return lines\\n+\\n+ top = self._c(_DARK_GRAY, f\\\"{_TL}{_H_LINE * inner}{_TR}\\\")\\n+ bot = self._c(_DARK_GRAY, f\\\"{_BL}{_H_LINE * inner}{_BR}\\\")\\n+\\n+ # Title: ◆ cli-anything · Shotcut\\n+ icon = self._c(_CYAN + _BOLD, \\\"◆\\\")\\n+ brand = self._c(_CYAN + _BOLD, \\\"cli-anything\\\")\\n+ dot = self._c(_DARK_GRAY, \\\"·\\\")\\n+ name = self._c(self.accent + _BOLD, self.display_name)\\n+ title = f\\\" {icon} {brand} {dot} {name}\\\"\\n+\\n+ ver = f\\\" {self._c(_DARK_GRAY, f' v{self.version}')}\\\"\\n+ tip = f\\\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\\\"\\n+ empty = \\\"\\\"\\n+\\n+ meta_lines: list[str] = []\\n+ meta_lines.extend(_meta_lines(\\\"Install:\\\", self.skill_install_cmd))\\n+ meta_lines.extend(_meta_lines(\\\"Global skill:\\\", _display_home_path(self.global_skill_path)))\\n+ print(top)\\n+ print(_box_line(title))\\n+ print(_box_line(ver))\\n+ for line in meta_lines:\\n+ print(_box_line(line))\\n+ print(_box_line(empty))\\n+ print(_box_line(tip))\\n+ print(bot)\\n+ print()\\n+\\n+ # ── Prompt ────────────────────────────────────────────────────────\\n+\\n+ def prompt(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a styled prompt string for prompt_toolkit or input().\\n+\\n+ Args:\\n+ project_name: Current project name (empty if none open).\\n+ modified: Whether the project has unsaved changes.\\n+ context: Optional extra context to show in prompt.\\n+\\n+ Returns:\\n+ Formatted prompt string.\\n+ \\\"\\\"\\\"\\n+ parts = []\\n+\\n+ # Icon\\n+ if self._color:\\n+ parts.append(f\\\"{_CYAN}◆{_RESET} \\\")\\n+ else:\\n+ parts.append(\\\"> \\\")\\n+\\n+ # Software name\\n+ parts.append(self._c(self.accent + _BOLD, self.software))\\n+\\n+ # Project context\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ parts.append(f\\\" {self._c(_DARK_GRAY, '[')}\\\")\\n+ parts.append(self._c(_LIGHT_GRAY, f\\\"{ctx}{mod}\\\"))\\n+ parts.append(self._c(_DARK_GRAY, ']'))\\n+\\n+ parts.append(self._c(_GRAY, \\\" ❯ \\\"))\\n+\\n+ return \\\"\\\".join(parts)\\n+\\n+ def prompt_tokens(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Build prompt_toolkit formatted text tokens for the prompt.\\n+\\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\\n+\\n+ Returns:\\n+ list of (style, text) tuples for prompt_toolkit.\\n+ \\\"\\\"\\\"\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+ tokens = []\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\nnew file mode 100644\\nindex 000000000..3296206c8\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\n@@ -0,0 +1,568 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ display_overrides = {\\\"wavetone\\\": \\\"WaveTone\\\"}\\n+ self.display_name = display_overrides.get(self.software, software.replace(\\\"_\\\", \\\" \\\").title())\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\\n+\\n+ # History file\\n+ if history_file is None:\\n+ hist_dir = Path.home() / f\\\".cli-anything-{self.software}\\\"\\n+ hist_dir.mkdir(parents=True, exist_ok=True)\\n+ self.history_file = str(hist_dir / \\\"history\\\")\\n+ else:\\n+ self.history_file = history_file\\n+\\n+ # Detect terminal capabilities\\n+ self._color = self._detect_color_support()\\n+\\n+ def _detect_color_support(self) -> bool:\\n+ \\\"\\\"\\\"Check if terminal supports color.\\\"\\\"\\\"\\n+ if os.environ.get(\\\"NO_COLOR\\\"):\\n+ return False\\n+ if os.environ.get(\\\"CLI_ANYTHING_NO_COLOR\\\"):\\n+ return False\\n+ if not hasattr(sys.stdout, \\\"isatty\\\"):\\n+ return False\\n+ return sys.stdout.isatty()\\n+\\n+ def _c(self, code: str, text: str) -> str:\\n+ \\\"\\\"\\\"Apply color code if colors are supported.\\\"\\\"\\\"\\n+ if not self._color:\\n+ return text\\n+ return f\\\"{code}{text}{_RESET}\\\"\\n+\\n+ # ── Banner ────────────────────────────────────────────────────────\\n+\\n+ def print_banner(self):\\n+ \\\"\\\"\\\"Print the startup banner with branding.\\\"\\\"\\\"\\n+ import textwrap\\n+\\n+ inner = 72\\n+\\n+ def _box_line(content: str) -> str:\\n+ \\\"\\\"\\\"Wrap content in box drawing, padding to inner width.\\\"\\\"\\\"\\n+ pad = inner - _visible_len(content)\\n+ vl = self._c(_DARK_GRAY, _V_LINE)\\n+ return f\\\"{vl}{content}{' ' * max(0, pad)}{vl}\\\"\\n+\\n+ def _meta_lines(label: str, value: str) -> list[str]:\\n+ \\\"\\\"\\\"Wrap a metadata line for the banner box.\\\"\\\"\\\"\\n+ icon = self._c(_MAGENTA, \\\"◇\\\")\\n+ label_text = self._c(_DARK_GRAY, label)\\n+ prefix = f\\\" {icon} {label_text} \\\"\\n+ available = max(12, inner - _visible_len(prefix))\\n+ wrapped = textwrap.wrap(\\n+ value,\\n+ width=available,\\n+ break_long_words=True,\\n+ break_on_hyphens=False,\\n+ ) or [\\\"\\\"]\\n+ lines = [f\\\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\\\"]\\n+ continuation_prefix = \\\" \\\" * _visible_len(prefix)\\n+ for chunk in wrapped[1:]:\\n+ lines.append(f\\\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\\\")\\n+ return lines\\n+\\n+ top = self._c(_DARK_GRAY, f\\\"{_TL}{_H_LINE * inner}{_TR}\\\")\\n+ bot = self._c(_DARK_GRAY, f\\\"{_BL}{_H_LINE * inner}{_BR}\\\")\\n+\\n+ # Title: ◆ cli-anything · Shotcut\\n+ icon = self._c(_CYAN + _BOLD, \\\"◆\\\")\\n+ brand = self._c(_CYAN + _BOLD, \\\"cli-anything\\\")\\n+ dot = self._c(_DARK_GRAY, \\\"·\\\")\\n+ name = self._c(self.accent + _BOLD, self.display_name)\\n+ title = f\\\" {icon} {brand} {dot} {name}\\\"\\n+\\n+ ver = f\\\" {self._c(_DARK_GRAY, f' v{self.version}')}\\\"\\n+ tip = f\\\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\\\"\\n+ empty = \\\"\\\"\\n+\\n+ meta_lines: list[str] = []\\n+ meta_lines.extend(_meta_lines(\\\"Install:\\\", self.skill_install_cmd))\\n+ if self.skill_path:\\n+ meta_lines.extend(_meta_lines(\\\"Local skill:\\\", _display_home_path(self.skill_path)))\\n+ meta_lines.extend(_meta_lines(\\\"Global skill:\\\", _display_home_path(self.global_skill_path)))\\n+ print(top)\\n+ print(_box_line(title))\\n+ print(_box_line(ver))\\n+ for line in meta_lines:\\n+ print(_box_line(line))\\n+ print(_box_line(empty))\\n+ print(_box_line(tip))\\n+ print(bot)\\n+ print()\\n+\\n+ # ── Prompt ────────────────────────────────────────────────────────\\n+\\n+ def prompt(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a styled prompt string for prompt_toolkit or input().\\n+\\n+ Args:\\n+ project_name: Current project name (empty if none open).\\n+ modified: Whether the project has unsaved changes.\\n+ context: Optional extra context to show in prompt.\\n+\\n+ Returns:\\n+ Formatted prompt string.\\n+ \\\"\\\"\\\"\\n+ parts = []\\n+\\n+ # Icon\\n+ if self._color:\\n+ parts.append(f\\\"{_CYAN}◆{_RESET} \\\")\\n+ else:\\n+ parts.append(\\\"> \\\")\\n+\\n+ # Software name\\n+ parts.append(self._c(self.accent + _BOLD, self.software))\\n+\\n+ # Project context\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ parts.append(f\\\" {self._c(_DARK_GRAY, '[')}\\\")\\n+ parts.append(self._c(_LIGHT_GRAY, f\\\"{ctx}{mod}\\\"))\\n+ parts.append(self._c(_DARK_GRAY, ']'))\\n+\\n+ parts.append(self._c(_GRAY, \\\" ❯ \\\"))\\n+\\n+ return \\\"\\\".join(parts)\\n+\\n+ def prompt_tokens(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Build prompt_toolkit formatted text tokens for the prompt.\\n+\\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\\n+\\n+ Returns:\\n+ list of (style, text) tuples for prompt_toolkit.\\n+ \\\"\\\"\\\"\\n+ tokens = []\\n+\\n+ tokens.append((\\\"class:icon\\\", \\\"◆ \\\"))\\n+ tokens.append((\\\"class:software\\\", self.software))\\n+\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ tokens.append((\\\"class:bracket\\\", \\\" [\\\"))\\n+ tokens.append((\\\"class:context\\\", f\\\"{ctx}{mod}\\\"))\\n+ tokens.append((\\\"class:bracket\\\", \\\"]\\\"))\\n+\\n+ tokens.append((\\\"class:arrow\\\", \\\" ❯ \\\"))\\n+\\n+ return tokens\\n+\\n+ def get_prompt_style(self):\\n+ \\\"\\\"\\\"Get a prompt_toolkit Style object matching the skin.\\n+\\n+ Returns:\\n+ prompt_toolkit.styles.Style\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit.styles import Style\\n+ except ImportError:\\n+ return None\\n+\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+\\n+ return Style.from_dict({\\n+ \\\"icon\\\": \\\"#5fdfdf bold\\\", # cyan brand color\\n+ \\\"software\\\": f\\\"{accent_hex} bold\\\",\\n+ \\\"bracket\\\": \\\"#585858\\\",\\n+ \\\"context\\\": \\\"#bcbcbc\\\",\\n+ \\\"arrow\\\": \\\"#808080\\\",\\n+ # Completion menu\\n+ \\\"completion-menu.completion\\\": \\\"bg:#303030 #bcbcbc\\\",\\n+ \\\"completion-menu.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ \\\"completion-menu.meta.completion\\\": \\\"bg:#303030 #808080\\\",\\n+ \\\"completion-menu.meta.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ # Auto-suggest\\n+ \\\"auto-suggest\\\": \\\"#585858\\\",\\n+ # Bottom toolbar\\n+ \\\"bottom-toolbar\\\": \\\"bg:#1c1c1c #808080\\\",\\n+ \\\"bottom-toolbar.text\\\": \\\"#808080\\\",\\n+ })\\n+\\n+ # ── Messages ──────────────────────────────────────────────────────\\n+\\n+ def success(self, message: str):\\n+ \\\"\\\"\\\"Print a success message with green checkmark.\\\"\\\"\\\"\\n+ icon = self._c(_GREEN + _BOLD, \\\"✓\\\")\\n+ print(f\\\" {icon} {self._c(_GREEN, message)}\\\")\\n+\\n+ def error(self, message: str):\\n+ \\\"\\\"\\\"Print an error message with red cross.\\\"\\\"\\\"\\n+ icon = self._c(_RED + _BOLD, \\\"✗\\\")\\n+ print(f\\\" {icon} {self._c(_RED, message)}\\\", file=sys.stderr)\\n+\\n+ def warning(self, message: str):\\n+ \\\"\\\"\\\"Print a warning message with yellow triangle.\\\"\\\"\\\"\\n+ icon = self._c(_YELLOW + _BOLD, \\\"⚠\\\")\\n+ print(f\\\" {icon} {self._c(_YELLOW, message)}\\\")\\n+\\n+ def info(self, message: str):\\n+ \\\"\\\"\\\"Print an info message with blue dot.\\\"\\\"\\\"\\n+ icon = self._c(_BLUE, \\\"●\\\")\\n+ print(f\\\" {icon} {self._c(_LIGHT_GRAY, message)}\\\")\\n+\\n+ def hint(self, message: str):\\n+ \\\"\\\"\\\"Print a subtle hint message.\\\"\\\"\\\"\\n+ print(f\\\" {self._c(_DARK_GRAY, message)}\\\")\\n+\\n+ def section(self, title: str):\\n+ \\\"\\\"\\\"Print a section header.\\\"\\\"\\\"\\n+ print()\\n+ print(f\\\" {self._c(self.accent + _BOLD, title)}\\\")\\n+ print(f\\\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\\\")\\n+\\n+ # ── Status display ────────────────────────────────────────────────\\n+\\n+ def status(self, label: str, value: str):\\n+ \\\"\\\"\\\"Print a key-value status line.\\\"\\\"\\\"\\n+ lbl = self._c(_GRAY, f\\\" {label}:\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def status_block(self, items: dict[str, str], title: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a block of status key-value pairs.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs.\\n+ title: Optional title for the block.\\n+ \\\"\\\"\\\"\\n+ if title:\\n+ self.section(title)\\n+\\n+ max_key = max(len(k) for k in items) if items else 0\\n+ for label, value in items.items():\\n+ lbl = self._c(_GRAY, f\\\" {label:<{max_key}}\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def progress(self, current: int, total: int, label: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a simple progress indicator.\\n+\\n+ Args:\\n+ current: Current step number.\\n+ total: Total number of steps.\\n+ label: Optional label for the progress.\\n+ \\\"\\\"\\\"\\n+ pct = int(current / total * 100) if total > 0 else 0\\n+ bar_width = 20\\n+ filled = int(bar_width * current / total) if total > 0 else 0\\n+ bar = \\\"█\\\" * filled + \\\"░\\\" * (bar_width - filled)\\n+ text = f\\\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\\\"\\n+ if label:\\n+ text += f\\\" {self._c(_LIGHT_GRAY, label)}\\\"\\n+ print(text)\\n+\\n+ # ── Table display ─────────────────────────────────────────────────\\n+\\n+ def table(self, headers: list[str], rows: list[list[str]],\\n+ max_col_width: int = 40):\\n+ \\\"\\\"\\\"Print a formatted table with box-drawing characters.\\n+\\n+ Args:\\n+ headers: Column header strings.\\n+ rows: List of rows, each a list of cell strings.\\n+ max_col_width: Maximum column width before truncation.\\n+ \\\"\\\"\\\"\\n+ if not headers:\\n+ return\\n+\\n+ # Calculate column widths\\n+ col_widths = [min(len(h), max_col_width) for h in headers]\\n+ for row in rows:\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ col_widths[i] = min(\\n+ max(col_widths[i], len(str(cell))), max_col_width\\n+ )\\n+\\n+ def pad(text: str, width: int) -> str:\\n+ t = str(text)[:width]\\n+ return t + \\\" \\\" * (width - len(t))\\n+\\n+ # Header\\n+ header_cells = [\\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\\n+ for i, h in enumerate(headers)\\n+ ]\\n+ sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ header_line = f\\\" {sep.join(header_cells)}\\\"\\n+ print(header_line)\\n+\\n+ # Separator\\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\\n+ sep_line = f\\\" {sep.join(sep_parts)}\\\"\\n+ print(sep_line)\\n+\\n+ # Rows\\n+ for row in rows:\\n+ cells = []\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\\n+ row_sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ print(f\\\" {row_sep.join(cells)}\\\")\\n+\\n+ # ── Help display ──────────────────────────────────────────────────\\n+\\n+ def help(self, commands: dict[str, str]):\\n+ \\\"\\\"\\\"Print a formatted help listing.\\n+\\n+ Args:\\n+ commands: Dict of command -> description pairs.\\n+ \\\"\\\"\\\"\\n+ self.section(\\\"Commands\\\")\\n+ max_cmd = max(len(c) for c in commands) if commands else 0\\n+ for cmd, desc in commands.items():\\n+ cmd_styled = self._c(self.accent, f\\\" {cmd:<{max_cmd}}\\\")\\n+ desc_styled = self._c(_GRAY, f\\\" {desc}\\\")\\n+ print(f\\\"{cmd_styled}{desc_styled}\\\")\\n+ print()\\n+\\n+ # ── Goodbye ───────────────────────────────────────────────────────\\n+\\n+ def print_goodbye(self):\\n+ \\\"\\\"\\\"Print a styled goodbye message.\\\"\\\"\\\"\\n+ print(f\\\"\\\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\\\n\\\")\\n+\\n+ # ── Prompt toolkit session factory ────────────────────────────────\\n+\\n+ def create_prompt_session(self):\\n+ \\\"\\\"\\\"Create a prompt_toolkit PromptSession with skin styling.\\n+\\n+ Returns:\\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit import PromptSession\\n+ from prompt_toolkit.history import FileHistory\\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\\n+\\n+ style = self.get_prompt_style()\\n+\\n+ session = PromptSession(\\n+ history=FileHistory(self.history_file),\\n+ auto_suggest=AutoSuggestFromHistory(),\\n+ style=style,\\n+ enable_history_search=True,\\n+ )\\n+ return session\\n+ except ImportError:\\n+ return None\\n+\\n+ def get_input(self, pt_session, project_name: str = \\\"\\\",\\n+ modified: bool = False, context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Get input from user using prompt_toolkit or fallback.\\n+\\n+ Args:\\n+ pt_session: A prompt_toolkit PromptSession (or None).\\n+ project_name: Current project name.\\n+ modified: Whether project has unsaved changes.\\n+ context: Optional context string.\\n+\\n+ Returns:\\n+ User input string (stripped).\\n+ \\\"\\\"\\\"\\n+ if pt_session is not None:\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ tokens = self.prompt_tokens(project_name, modified, context)\\n+ return pt_session.prompt(FormattedText(tokens)).strip()\\n+ else:\\n+ raw_prompt = self.prompt(project_name, modified, context)\\n+ return input(raw_prompt).strip()\\n+\\n+ # ── Toolbar builder ───────────────────────────────────────────────\\n+\\n+ def bottom_toolbar(self, items: dict[str, str]):\\n+ \\\"\\\"\\\"Create a bottom toolbar callback for prompt_toolkit.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs to show in toolbar.\\n+\\n+ Returns:\\n+ A callable that returns FormattedText for the toolbar.\\n+ \\\"\\\"\\\"\\n+ def toolbar():\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ parts = []\\n+ for i, (k, v) in enumerate(items.items()):\\n+ if i > 0:\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", \\\" │ \\\"))\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", f\\\" {k}: \\\"))\\n+ parts.append((\\\"class:bottom-toolbar\\\", v))\\n+ return FormattedText(parts)\\n+ return toolbar\\n+\\n+\\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\\n+\\n+_ANSI_256_TO_HEX = {\\n+ \\\"\\\\033[38;5;33m\\\": \\\"#0087ff\\\", # audacity navy blue\\n+ \\\"\\\\033[38;5;35m\\\": \\\"#00af5f\\\", # shotcut teal\\n+ \\\"\\\\033[38;5;39m\\\": \\\"#00afff\\\", # inkscape bright blue\\n+ \\\"\\\\033[38;5;40m\\\": \\\"#00d700\\\", # libreoffice green\\n+ \\\"\\\\033[38;5;55m\\\": \\\"#5f00af\\\", # obs purple\\n+ \\\"\\\\033[38;5;69m\\\": \\\"#5f87ff\\\", # kdenlive slate blue\\n+ \\\"\\\\033[38;5;75m\\\": \\\"#5fafff\\\", # default sky blue\\n+ \\\"\\\\033[38;5;80m\\\": \\\"#5fd7d7\\\", # brand cyan\\n+ \\\"\\\\033[38;5;208m\\\": \\\"#ff8700\\\", # blender deep orange\\n+ \\\"\\\\033[38;5;214m\\\": \\\"#ffaf00\\\", # gimp warm orange\\n+}\\n\"\n },\n {\n \"comment\": \"`FormattedText` is imported in `create_prompt_session()` but not used in that function. Removing the unused import will avoid lint failures and reduce noise.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\",\n \"hunk\": \"@@ -0,0 +1,567 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ self.display_name = software.replace(\\\"_\\\", \\\" \\\").title()\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\\n+\\n+ # History file\\n+ if history_file is None:\\n+ hist_dir = Path.home() / f\\\".cli-anything-{self.software}\\\"\\n+ hist_dir.mkdir(parents=True, exist_ok=True)\\n+ self.history_file = str(hist_dir / \\\"history\\\")\\n+ else:\\n+ self.history_file = history_file\\n+\\n+ # Detect terminal capabilities\\n+ self._color = self._detect_color_support()\\n+\\n+ def _detect_color_support(self) -> bool:\\n+ \\\"\\\"\\\"Check if terminal supports color.\\\"\\\"\\\"\\n+ if os.environ.get(\\\"NO_COLOR\\\"):\\n+ return False\\n+ if os.environ.get(\\\"CLI_ANYTHING_NO_COLOR\\\"):\\n+ return False\\n+ if not hasattr(sys.stdout, \\\"isatty\\\"):\\n+ return False\\n+ return sys.stdout.isatty()\\n+\\n+ def _c(self, code: str, text: str) -> str:\\n+ \\\"\\\"\\\"Apply color code if colors are supported.\\\"\\\"\\\"\\n+ if not self._color:\\n+ return text\\n+ return f\\\"{code}{text}{_RESET}\\\"\\n+\\n+ # ── Banner ────────────────────────────────────────────────────────\\n+\\n+ def print_banner(self):\\n+ \\\"\\\"\\\"Print the startup banner with branding.\\\"\\\"\\\"\\n+ import textwrap\\n+\\n+ inner = 72\\n+\\n+ def _box_line(content: str) -> str:\\n+ \\\"\\\"\\\"Wrap content in box drawing, padding to inner width.\\\"\\\"\\\"\\n+ pad = inner - _visible_len(content)\\n+ vl = self._c(_DARK_GRAY, _V_LINE)\\n+ return f\\\"{vl}{content}{' ' * max(0, pad)}{vl}\\\"\\n+\\n+ def _meta_lines(label: str, value: str) -> list[str]:\\n+ \\\"\\\"\\\"Wrap a metadata line for the banner box.\\\"\\\"\\\"\\n+ icon = self._c(_MAGENTA, \\\"◇\\\")\\n+ label_text = self._c(_DARK_GRAY, label)\\n+ prefix = f\\\" {icon} {label_text} \\\"\\n+ available = max(12, inner - _visible_len(prefix))\\n+ wrapped = textwrap.wrap(\\n+ value,\\n+ width=available,\\n+ break_long_words=True,\\n+ break_on_hyphens=False,\\n+ ) or [\\\"\\\"]\\n+ lines = [f\\\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\\\"]\\n+ continuation_prefix = \\\" \\\" * _visible_len(prefix)\\n+ for chunk in wrapped[1:]:\\n+ lines.append(f\\\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\\\")\\n+ return lines\\n+\\n+ top = self._c(_DARK_GRAY, f\\\"{_TL}{_H_LINE * inner}{_TR}\\\")\\n+ bot = self._c(_DARK_GRAY, f\\\"{_BL}{_H_LINE * inner}{_BR}\\\")\\n+\\n+ # Title: ◆ cli-anything · Shotcut\\n+ icon = self._c(_CYAN + _BOLD, \\\"◆\\\")\\n+ brand = self._c(_CYAN + _BOLD, \\\"cli-anything\\\")\\n+ dot = self._c(_DARK_GRAY, \\\"·\\\")\\n+ name = self._c(self.accent + _BOLD, self.display_name)\\n+ title = f\\\" {icon} {brand} {dot} {name}\\\"\\n+\\n+ ver = f\\\" {self._c(_DARK_GRAY, f' v{self.version}')}\\\"\\n+ tip = f\\\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\\\"\\n+ empty = \\\"\\\"\\n+\\n+ meta_lines: list[str] = []\\n+ meta_lines.extend(_meta_lines(\\\"Install:\\\", self.skill_install_cmd))\\n+ meta_lines.extend(_meta_lines(\\\"Global skill:\\\", _display_home_path(self.global_skill_path)))\\n+ print(top)\\n+ print(_box_line(title))\\n+ print(_box_line(ver))\\n+ for line in meta_lines:\\n+ print(_box_line(line))\\n+ print(_box_line(empty))\\n+ print(_box_line(tip))\\n+ print(bot)\\n+ print()\\n+\\n+ # ── Prompt ────────────────────────────────────────────────────────\\n+\\n+ def prompt(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a styled prompt string for prompt_toolkit or input().\\n+\\n+ Args:\\n+ project_name: Current project name (empty if none open).\\n+ modified: Whether the project has unsaved changes.\\n+ context: Optional extra context to show in prompt.\\n+\\n+ Returns:\\n+ Formatted prompt string.\\n+ \\\"\\\"\\\"\\n+ parts = []\\n+\\n+ # Icon\\n+ if self._color:\\n+ parts.append(f\\\"{_CYAN}◆{_RESET} \\\")\\n+ else:\\n+ parts.append(\\\"> \\\")\\n+\\n+ # Software name\\n+ parts.append(self._c(self.accent + _BOLD, self.software))\\n+\\n+ # Project context\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ parts.append(f\\\" {self._c(_DARK_GRAY, '[')}\\\")\\n+ parts.append(self._c(_LIGHT_GRAY, f\\\"{ctx}{mod}\\\"))\\n+ parts.append(self._c(_DARK_GRAY, ']'))\\n+\\n+ parts.append(self._c(_GRAY, \\\" ❯ \\\"))\\n+\\n+ return \\\"\\\".join(parts)\\n+\\n+ def prompt_tokens(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Build prompt_toolkit formatted text tokens for the prompt.\\n+\\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\\n+\\n+ Returns:\\n+ list of (style, text) tuples for prompt_toolkit.\\n+ \\\"\\\"\\\"\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+ tokens = []\\n+\\n+ tokens.append((\\\"class:icon\\\", \\\"◆ \\\"))\\n+ tokens.append((\\\"class:software\\\", self.software))\\n+\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ tokens.append((\\\"class:bracket\\\", \\\" [\\\"))\\n+ tokens.append((\\\"class:context\\\", f\\\"{ctx}{mod}\\\"))\\n+ tokens.append((\\\"class:bracket\\\", \\\"]\\\"))\\n+\\n+ tokens.append((\\\"class:arrow\\\", \\\" ❯ \\\"))\\n+\\n+ return tokens\\n+\\n+ def get_prompt_style(self):\\n+ \\\"\\\"\\\"Get a prompt_toolkit Style object matching the skin.\\n+\\n+ Returns:\\n+ prompt_toolkit.styles.Style\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit.styles import Style\\n+ except ImportError:\\n+ return None\\n+\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+\\n+ return Style.from_dict({\\n+ \\\"icon\\\": \\\"#5fdfdf bold\\\", # cyan brand color\\n+ \\\"software\\\": f\\\"{accent_hex} bold\\\",\\n+ \\\"bracket\\\": \\\"#585858\\\",\\n+ \\\"context\\\": \\\"#bcbcbc\\\",\\n+ \\\"arrow\\\": \\\"#808080\\\",\\n+ # Completion menu\\n+ \\\"completion-menu.completion\\\": \\\"bg:#303030 #bcbcbc\\\",\\n+ \\\"completion-menu.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ \\\"completion-menu.meta.completion\\\": \\\"bg:#303030 #808080\\\",\\n+ \\\"completion-menu.meta.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ # Auto-suggest\\n+ \\\"auto-suggest\\\": \\\"#585858\\\",\\n+ # Bottom toolbar\\n+ \\\"bottom-toolbar\\\": \\\"bg:#1c1c1c #808080\\\",\\n+ \\\"bottom-toolbar.text\\\": \\\"#808080\\\",\\n+ })\\n+\\n+ # ── Messages ──────────────────────────────────────────────────────\\n+\\n+ def success(self, message: str):\\n+ \\\"\\\"\\\"Print a success message with green checkmark.\\\"\\\"\\\"\\n+ icon = self._c(_GREEN + _BOLD, \\\"✓\\\")\\n+ print(f\\\" {icon} {self._c(_GREEN, message)}\\\")\\n+\\n+ def error(self, message: str):\\n+ \\\"\\\"\\\"Print an error message with red cross.\\\"\\\"\\\"\\n+ icon = self._c(_RED + _BOLD, \\\"✗\\\")\\n+ print(f\\\" {icon} {self._c(_RED, message)}\\\", file=sys.stderr)\\n+\\n+ def warning(self, message: str):\\n+ \\\"\\\"\\\"Print a warning message with yellow triangle.\\\"\\\"\\\"\\n+ icon = self._c(_YELLOW + _BOLD, \\\"⚠\\\")\\n+ print(f\\\" {icon} {self._c(_YELLOW, message)}\\\")\\n+\\n+ def info(self, message: str):\\n+ \\\"\\\"\\\"Print an info message with blue dot.\\\"\\\"\\\"\\n+ icon = self._c(_BLUE, \\\"●\\\")\\n+ print(f\\\" {icon} {self._c(_LIGHT_GRAY, message)}\\\")\\n+\\n+ def hint(self, message: str):\\n+ \\\"\\\"\\\"Print a subtle hint message.\\\"\\\"\\\"\\n+ print(f\\\" {self._c(_DARK_GRAY, message)}\\\")\\n+\\n+ def section(self, title: str):\\n+ \\\"\\\"\\\"Print a section header.\\\"\\\"\\\"\\n+ print()\\n+ print(f\\\" {self._c(self.accent + _BOLD, title)}\\\")\\n+ print(f\\\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\\\")\\n+\\n+ # ── Status display ────────────────────────────────────────────────\\n+\\n+ def status(self, label: str, value: str):\\n+ \\\"\\\"\\\"Print a key-value status line.\\\"\\\"\\\"\\n+ lbl = self._c(_GRAY, f\\\" {label}:\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def status_block(self, items: dict[str, str], title: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a block of status key-value pairs.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs.\\n+ title: Optional title for the block.\\n+ \\\"\\\"\\\"\\n+ if title:\\n+ self.section(title)\\n+\\n+ max_key = max(len(k) for k in items) if items else 0\\n+ for label, value in items.items():\\n+ lbl = self._c(_GRAY, f\\\" {label:<{max_key}}\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def progress(self, current: int, total: int, label: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a simple progress indicator.\\n+\\n+ Args:\\n+ current: Current step number.\\n+ total: Total number of steps.\\n+ label: Optional label for the progress.\\n+ \\\"\\\"\\\"\\n+ pct = int(current / total * 100) if total > 0 else 0\\n+ bar_width = 20\\n+ filled = int(bar_width * current / total) if total > 0 else 0\\n+ bar = \\\"█\\\" * filled + \\\"░\\\" * (bar_width - filled)\\n+ text = f\\\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\\\"\\n+ if label:\\n+ text += f\\\" {self._c(_LIGHT_GRAY, label)}\\\"\\n+ print(text)\\n+\\n+ # ── Table display ─────────────────────────────────────────────────\\n+\\n+ def table(self, headers: list[str], rows: list[list[str]],\\n+ max_col_width: int = 40):\\n+ \\\"\\\"\\\"Print a formatted table with box-drawing characters.\\n+\\n+ Args:\\n+ headers: Column header strings.\\n+ rows: List of rows, each a list of cell strings.\\n+ max_col_width: Maximum column width before truncation.\\n+ \\\"\\\"\\\"\\n+ if not headers:\\n+ return\\n+\\n+ # Calculate column widths\\n+ col_widths = [min(len(h), max_col_width) for h in headers]\\n+ for row in rows:\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ col_widths[i] = min(\\n+ max(col_widths[i], len(str(cell))), max_col_width\\n+ )\\n+\\n+ def pad(text: str, width: int) -> str:\\n+ t = str(text)[:width]\\n+ return t + \\\" \\\" * (width - len(t))\\n+\\n+ # Header\\n+ header_cells = [\\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\\n+ for i, h in enumerate(headers)\\n+ ]\\n+ sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ header_line = f\\\" {sep.join(header_cells)}\\\"\\n+ print(header_line)\\n+\\n+ # Separator\\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\\n+ sep_line = f\\\" {sep.join(sep_parts)}\\\"\\n+ print(sep_line)\\n+\\n+ # Rows\\n+ for row in rows:\\n+ cells = []\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\\n+ row_sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ print(f\\\" {row_sep.join(cells)}\\\")\\n+\\n+ # ── Help display ──────────────────────────────────────────────────\\n+\\n+ def help(self, commands: dict[str, str]):\\n+ \\\"\\\"\\\"Print a formatted help listing.\\n+\\n+ Args:\\n+ commands: Dict of command -> description pairs.\\n+ \\\"\\\"\\\"\\n+ self.section(\\\"Commands\\\")\\n+ max_cmd = max(len(c) for c in commands) if commands else 0\\n+ for cmd, desc in commands.items():\\n+ cmd_styled = self._c(self.accent, f\\\" {cmd:<{max_cmd}}\\\")\\n+ desc_styled = self._c(_GRAY, f\\\" {desc}\\\")\\n+ print(f\\\"{cmd_styled}{desc_styled}\\\")\\n+ print()\\n+\\n+ # ── Goodbye ───────────────────────────────────────────────────────\\n+\\n+ def print_goodbye(self):\\n+ \\\"\\\"\\\"Print a styled goodbye message.\\\"\\\"\\\"\\n+ print(f\\\"\\\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\\\n\\\")\\n+\\n+ # ── Prompt toolkit session factory ────────────────────────────────\\n+\\n+ def create_prompt_session(self):\\n+ \\\"\\\"\\\"Create a prompt_toolkit PromptSession with skin styling.\\n+\\n+ Returns:\\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit import PromptSession\\n+ from prompt_toolkit.history import FileHistory\\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\\n+ from prompt_toolkit.formatted_text import FormattedText\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\nnew file mode 100644\\nindex 000000000..3296206c8\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\n@@ -0,0 +1,568 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ display_overrides = {\\\"wavetone\\\": \\\"WaveTone\\\"}\\n+ self.display_name = display_overrides.get(self.software, software.replace(\\\"_\\\", \\\" \\\").title())\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\\n+\\n+ # History file\\n+ if history_file is None:\\n+ hist_dir = Path.home() / f\\\".cli-anything-{self.software}\\\"\\n+ hist_dir.mkdir(parents=True, exist_ok=True)\\n+ self.history_file = str(hist_dir / \\\"history\\\")\\n+ else:\\n+ self.history_file = history_file\\n+\\n+ # Detect terminal capabilities\\n+ self._color = self._detect_color_support()\\n+\\n+ def _detect_color_support(self) -> bool:\\n+ \\\"\\\"\\\"Check if terminal supports color.\\\"\\\"\\\"\\n+ if os.environ.get(\\\"NO_COLOR\\\"):\\n+ return False\\n+ if os.environ.get(\\\"CLI_ANYTHING_NO_COLOR\\\"):\\n+ return False\\n+ if not hasattr(sys.stdout, \\\"isatty\\\"):\\n+ return False\\n+ return sys.stdout.isatty()\\n+\\n+ def _c(self, code: str, text: str) -> str:\\n+ \\\"\\\"\\\"Apply color code if colors are supported.\\\"\\\"\\\"\\n+ if not self._color:\\n+ return text\\n+ return f\\\"{code}{text}{_RESET}\\\"\\n+\\n+ # ── Banner ────────────────────────────────────────────────────────\\n+\\n+ def print_banner(self):\\n+ \\\"\\\"\\\"Print the startup banner with branding.\\\"\\\"\\\"\\n+ import textwrap\\n+\\n+ inner = 72\\n+\\n+ def _box_line(content: str) -> str:\\n+ \\\"\\\"\\\"Wrap content in box drawing, padding to inner width.\\\"\\\"\\\"\\n+ pad = inner - _visible_len(content)\\n+ vl = self._c(_DARK_GRAY, _V_LINE)\\n+ return f\\\"{vl}{content}{' ' * max(0, pad)}{vl}\\\"\\n+\\n+ def _meta_lines(label: str, value: str) -> list[str]:\\n+ \\\"\\\"\\\"Wrap a metadata line for the banner box.\\\"\\\"\\\"\\n+ icon = self._c(_MAGENTA, \\\"◇\\\")\\n+ label_text = self._c(_DARK_GRAY, label)\\n+ prefix = f\\\" {icon} {label_text} \\\"\\n+ available = max(12, inner - _visible_len(prefix))\\n+ wrapped = textwrap.wrap(\\n+ value,\\n+ width=available,\\n+ break_long_words=True,\\n+ break_on_hyphens=False,\\n+ ) or [\\\"\\\"]\\n+ lines = [f\\\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\\\"]\\n+ continuation_prefix = \\\" \\\" * _visible_len(prefix)\\n+ for chunk in wrapped[1:]:\\n+ lines.append(f\\\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\\\")\\n+ return lines\\n+\\n+ top = self._c(_DARK_GRAY, f\\\"{_TL}{_H_LINE * inner}{_TR}\\\")\\n+ bot = self._c(_DARK_GRAY, f\\\"{_BL}{_H_LINE * inner}{_BR}\\\")\\n+\\n+ # Title: ◆ cli-anything · Shotcut\\n+ icon = self._c(_CYAN + _BOLD, \\\"◆\\\")\\n+ brand = self._c(_CYAN + _BOLD, \\\"cli-anything\\\")\\n+ dot = self._c(_DARK_GRAY, \\\"·\\\")\\n+ name = self._c(self.accent + _BOLD, self.display_name)\\n+ title = f\\\" {icon} {brand} {dot} {name}\\\"\\n+\\n+ ver = f\\\" {self._c(_DARK_GRAY, f' v{self.version}')}\\\"\\n+ tip = f\\\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\\\"\\n+ empty = \\\"\\\"\\n+\\n+ meta_lines: list[str] = []\\n+ meta_lines.extend(_meta_lines(\\\"Install:\\\", self.skill_install_cmd))\\n+ if self.skill_path:\\n+ meta_lines.extend(_meta_lines(\\\"Local skill:\\\", _display_home_path(self.skill_path)))\\n+ meta_lines.extend(_meta_lines(\\\"Global skill:\\\", _display_home_path(self.global_skill_path)))\\n+ print(top)\\n+ print(_box_line(title))\\n+ print(_box_line(ver))\\n+ for line in meta_lines:\\n+ print(_box_line(line))\\n+ print(_box_line(empty))\\n+ print(_box_line(tip))\\n+ print(bot)\\n+ print()\\n+\\n+ # ── Prompt ────────────────────────────────────────────────────────\\n+\\n+ def prompt(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a styled prompt string for prompt_toolkit or input().\\n+\\n+ Args:\\n+ project_name: Current project name (empty if none open).\\n+ modified: Whether the project has unsaved changes.\\n+ context: Optional extra context to show in prompt.\\n+\\n+ Returns:\\n+ Formatted prompt string.\\n+ \\\"\\\"\\\"\\n+ parts = []\\n+\\n+ # Icon\\n+ if self._color:\\n+ parts.append(f\\\"{_CYAN}◆{_RESET} \\\")\\n+ else:\\n+ parts.append(\\\"> \\\")\\n+\\n+ # Software name\\n+ parts.append(self._c(self.accent + _BOLD, self.software))\\n+\\n+ # Project context\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ parts.append(f\\\" {self._c(_DARK_GRAY, '[')}\\\")\\n+ parts.append(self._c(_LIGHT_GRAY, f\\\"{ctx}{mod}\\\"))\\n+ parts.append(self._c(_DARK_GRAY, ']'))\\n+\\n+ parts.append(self._c(_GRAY, \\\" ❯ \\\"))\\n+\\n+ return \\\"\\\".join(parts)\\n+\\n+ def prompt_tokens(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Build prompt_toolkit formatted text tokens for the prompt.\\n+\\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\\n+\\n+ Returns:\\n+ list of (style, text) tuples for prompt_toolkit.\\n+ \\\"\\\"\\\"\\n+ tokens = []\\n+\\n+ tokens.append((\\\"class:icon\\\", \\\"◆ \\\"))\\n+ tokens.append((\\\"class:software\\\", self.software))\\n+\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ tokens.append((\\\"class:bracket\\\", \\\" [\\\"))\\n+ tokens.append((\\\"class:context\\\", f\\\"{ctx}{mod}\\\"))\\n+ tokens.append((\\\"class:bracket\\\", \\\"]\\\"))\\n+\\n+ tokens.append((\\\"class:arrow\\\", \\\" ❯ \\\"))\\n+\\n+ return tokens\\n+\\n+ def get_prompt_style(self):\\n+ \\\"\\\"\\\"Get a prompt_toolkit Style object matching the skin.\\n+\\n+ Returns:\\n+ prompt_toolkit.styles.Style\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit.styles import Style\\n+ except ImportError:\\n+ return None\\n+\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+\\n+ return Style.from_dict({\\n+ \\\"icon\\\": \\\"#5fdfdf bold\\\", # cyan brand color\\n+ \\\"software\\\": f\\\"{accent_hex} bold\\\",\\n+ \\\"bracket\\\": \\\"#585858\\\",\\n+ \\\"context\\\": \\\"#bcbcbc\\\",\\n+ \\\"arrow\\\": \\\"#808080\\\",\\n+ # Completion menu\\n+ \\\"completion-menu.completion\\\": \\\"bg:#303030 #bcbcbc\\\",\\n+ \\\"completion-menu.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ \\\"completion-menu.meta.completion\\\": \\\"bg:#303030 #808080\\\",\\n+ \\\"completion-menu.meta.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ # Auto-suggest\\n+ \\\"auto-suggest\\\": \\\"#585858\\\",\\n+ # Bottom toolbar\\n+ \\\"bottom-toolbar\\\": \\\"bg:#1c1c1c #808080\\\",\\n+ \\\"bottom-toolbar.text\\\": \\\"#808080\\\",\\n+ })\\n+\\n+ # ── Messages ──────────────────────────────────────────────────────\\n+\\n+ def success(self, message: str):\\n+ \\\"\\\"\\\"Print a success message with green checkmark.\\\"\\\"\\\"\\n+ icon = self._c(_GREEN + _BOLD, \\\"✓\\\")\\n+ print(f\\\" {icon} {self._c(_GREEN, message)}\\\")\\n+\\n+ def error(self, message: str):\\n+ \\\"\\\"\\\"Print an error message with red cross.\\\"\\\"\\\"\\n+ icon = self._c(_RED + _BOLD, \\\"✗\\\")\\n+ print(f\\\" {icon} {self._c(_RED, message)}\\\", file=sys.stderr)\\n+\\n+ def warning(self, message: str):\\n+ \\\"\\\"\\\"Print a warning message with yellow triangle.\\\"\\\"\\\"\\n+ icon = self._c(_YELLOW + _BOLD, \\\"⚠\\\")\\n+ print(f\\\" {icon} {self._c(_YELLOW, message)}\\\")\\n+\\n+ def info(self, message: str):\\n+ \\\"\\\"\\\"Print an info message with blue dot.\\\"\\\"\\\"\\n+ icon = self._c(_BLUE, \\\"●\\\")\\n+ print(f\\\" {icon} {self._c(_LIGHT_GRAY, message)}\\\")\\n+\\n+ def hint(self, message: str):\\n+ \\\"\\\"\\\"Print a subtle hint message.\\\"\\\"\\\"\\n+ print(f\\\" {self._c(_DARK_GRAY, message)}\\\")\\n+\\n+ def section(self, title: str):\\n+ \\\"\\\"\\\"Print a section header.\\\"\\\"\\\"\\n+ print()\\n+ print(f\\\" {self._c(self.accent + _BOLD, title)}\\\")\\n+ print(f\\\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\\\")\\n+\\n+ # ── Status display ────────────────────────────────────────────────\\n+\\n+ def status(self, label: str, value: str):\\n+ \\\"\\\"\\\"Print a key-value status line.\\\"\\\"\\\"\\n+ lbl = self._c(_GRAY, f\\\" {label}:\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def status_block(self, items: dict[str, str], title: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a block of status key-value pairs.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs.\\n+ title: Optional title for the block.\\n+ \\\"\\\"\\\"\\n+ if title:\\n+ self.section(title)\\n+\\n+ max_key = max(len(k) for k in items) if items else 0\\n+ for label, value in items.items():\\n+ lbl = self._c(_GRAY, f\\\" {label:<{max_key}}\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def progress(self, current: int, total: int, label: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a simple progress indicator.\\n+\\n+ Args:\\n+ current: Current step number.\\n+ total: Total number of steps.\\n+ label: Optional label for the progress.\\n+ \\\"\\\"\\\"\\n+ pct = int(current / total * 100) if total > 0 else 0\\n+ bar_width = 20\\n+ filled = int(bar_width * current / total) if total > 0 else 0\\n+ bar = \\\"█\\\" * filled + \\\"░\\\" * (bar_width - filled)\\n+ text = f\\\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\\\"\\n+ if label:\\n+ text += f\\\" {self._c(_LIGHT_GRAY, label)}\\\"\\n+ print(text)\\n+\\n+ # ── Table display ─────────────────────────────────────────────────\\n+\\n+ def table(self, headers: list[str], rows: list[list[str]],\\n+ max_col_width: int = 40):\\n+ \\\"\\\"\\\"Print a formatted table with box-drawing characters.\\n+\\n+ Args:\\n+ headers: Column header strings.\\n+ rows: List of rows, each a list of cell strings.\\n+ max_col_width: Maximum column width before truncation.\\n+ \\\"\\\"\\\"\\n+ if not headers:\\n+ return\\n+\\n+ # Calculate column widths\\n+ col_widths = [min(len(h), max_col_width) for h in headers]\\n+ for row in rows:\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ col_widths[i] = min(\\n+ max(col_widths[i], len(str(cell))), max_col_width\\n+ )\\n+\\n+ def pad(text: str, width: int) -> str:\\n+ t = str(text)[:width]\\n+ return t + \\\" \\\" * (width - len(t))\\n+\\n+ # Header\\n+ header_cells = [\\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\\n+ for i, h in enumerate(headers)\\n+ ]\\n+ sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ header_line = f\\\" {sep.join(header_cells)}\\\"\\n+ print(header_line)\\n+\\n+ # Separator\\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\\n+ sep_line = f\\\" {sep.join(sep_parts)}\\\"\\n+ print(sep_line)\\n+\\n+ # Rows\\n+ for row in rows:\\n+ cells = []\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\\n+ row_sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ print(f\\\" {row_sep.join(cells)}\\\")\\n+\\n+ # ── Help display ──────────────────────────────────────────────────\\n+\\n+ def help(self, commands: dict[str, str]):\\n+ \\\"\\\"\\\"Print a formatted help listing.\\n+\\n+ Args:\\n+ commands: Dict of command -> description pairs.\\n+ \\\"\\\"\\\"\\n+ self.section(\\\"Commands\\\")\\n+ max_cmd = max(len(c) for c in commands) if commands else 0\\n+ for cmd, desc in commands.items():\\n+ cmd_styled = self._c(self.accent, f\\\" {cmd:<{max_cmd}}\\\")\\n+ desc_styled = self._c(_GRAY, f\\\" {desc}\\\")\\n+ print(f\\\"{cmd_styled}{desc_styled}\\\")\\n+ print()\\n+\\n+ # ── Goodbye ───────────────────────────────────────────────────────\\n+\\n+ def print_goodbye(self):\\n+ \\\"\\\"\\\"Print a styled goodbye message.\\\"\\\"\\\"\\n+ print(f\\\"\\\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\\\n\\\")\\n+\\n+ # ── Prompt toolkit session factory ────────────────────────────────\\n+\\n+ def create_prompt_session(self):\\n+ \\\"\\\"\\\"Create a prompt_toolkit PromptSession with skin styling.\\n+\\n+ Returns:\\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit import PromptSession\\n+ from prompt_toolkit.history import FileHistory\\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\\n+\\n+ style = self.get_prompt_style()\\n+\\n+ session = PromptSession(\\n+ history=FileHistory(self.history_file),\\n+ auto_suggest=AutoSuggestFromHistory(),\\n+ style=style,\\n+ enable_history_search=True,\\n+ )\\n+ return session\\n+ except ImportError:\\n+ return None\\n+\\n+ def get_input(self, pt_session, project_name: str = \\\"\\\",\\n+ modified: bool = False, context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Get input from user using prompt_toolkit or fallback.\\n+\\n+ Args:\\n+ pt_session: A prompt_toolkit PromptSession (or None).\\n+ project_name: Current project name.\\n+ modified: Whether project has unsaved changes.\\n+ context: Optional context string.\\n+\\n+ Returns:\\n+ User input string (stripped).\\n+ \\\"\\\"\\\"\\n+ if pt_session is not None:\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ tokens = self.prompt_tokens(project_name, modified, context)\\n+ return pt_session.prompt(FormattedText(tokens)).strip()\\n+ else:\\n+ raw_prompt = self.prompt(project_name, modified, context)\\n+ return input(raw_prompt).strip()\\n+\\n+ # ── Toolbar builder ───────────────────────────────────────────────\\n+\\n+ def bottom_toolbar(self, items: dict[str, str]):\\n+ \\\"\\\"\\\"Create a bottom toolbar callback for prompt_toolkit.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs to show in toolbar.\\n+\\n+ Returns:\\n+ A callable that returns FormattedText for the toolbar.\\n+ \\\"\\\"\\\"\\n+ def toolbar():\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ parts = []\\n+ for i, (k, v) in enumerate(items.items()):\\n+ if i > 0:\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", \\\" │ \\\"))\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", f\\\" {k}: \\\"))\\n+ parts.append((\\\"class:bottom-toolbar\\\", v))\\n+ return FormattedText(parts)\\n+ return toolbar\\n+\\n+\\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\\n+\\n+_ANSI_256_TO_HEX = {\\n+ \\\"\\\\033[38;5;33m\\\": \\\"#0087ff\\\", # audacity navy blue\\n+ \\\"\\\\033[38;5;35m\\\": \\\"#00af5f\\\", # shotcut teal\\n+ \\\"\\\\033[38;5;39m\\\": \\\"#00afff\\\", # inkscape bright blue\\n+ \\\"\\\\033[38;5;40m\\\": \\\"#00d700\\\", # libreoffice green\\n+ \\\"\\\\033[38;5;55m\\\": \\\"#5f00af\\\", # obs purple\\n+ \\\"\\\\033[38;5;69m\\\": \\\"#5f87ff\\\", # kdenlive slate blue\\n+ \\\"\\\\033[38;5;75m\\\": \\\"#5fafff\\\", # default sky blue\\n+ \\\"\\\\033[38;5;80m\\\": \\\"#5fd7d7\\\", # brand cyan\\n+ \\\"\\\\033[38;5;208m\\\": \\\"#ff8700\\\", # blender deep orange\\n+ \\\"\\\\033[38;5;214m\\\": \\\"#ffaf00\\\", # gimp warm orange\\n+}\\n\"\n },\n {\n \"comment\": \"The reported test totals for `wavetone` appear inconsistent with the harness’ own `TEST.md` (which documents 9 unit + 5 E2E = 14) and with the added tests (`test_core.py` has 9 tests). Please update this line to reflect the actual current totals.\",\n \"path\": \"README.md\",\n \"hunk\": \"@@ -1221,6 +1228,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\\n blender 208 passed ✅ (150 unit + 58 e2e)\\n inkscape 202 passed ✅ (148 unit + 54 e2e)\\n audacity 161 passed ✅ (107 unit + 54 e2e)\\n+wavetone 13 passed ✅ (8 unit + 5 e2e)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/README.md b/README.md\\nindex 17a93d0dd..509e6536b 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -667,7 +667,7 @@ The meta-skill points agents to the live CLI-Hub catalog, where they can choose\\n | **🤖 AI/ML Platforms** | Automate model training, inference pipelines, and hyperparameter tuning through structured commands | Stable Diffusion WebUI, ComfyUI, Ollama, InvokeAI, Text-generation-webui, Open WebUI, Fooocus, Kohya_ss, AnythingLLM, SillyTavern |\\n | **📊 Data & Analytics** | Enable programmatic data processing, visualization, and statistical analysis workflows | JupyterLab, Apache Superset, Metabase, Redash, DBeaver, KNIME, Orange, OpenSearch Dashboards, Lightdash |\\n | **💻 Development Tools** | Streamline code editing, building, testing, and deployment processes via command interfaces | Jenkins, Gitea, Hoppscotch, Portainer, pgAdmin, SonarQube, ArgoCD, OpenLens, Insomnia, Beekeeper Studio, **[iTerm2](https://iterm2.com)** |\\n-| **🎨 Creative & Media** | Control content creation, editing, and rendering workflows programmatically | Blender, GIMP, OBS Studio, Audacity, Krita, Kdenlive, Shotcut, Inkscape, Darktable, LMMS, Ardour |\\n+| **🎨 Creative & Media** | Control content creation, editing, and rendering workflows programmatically | Blender, GIMP, OBS Studio, Audacity, WaveTone, Krita, Kdenlive, Shotcut, Inkscape, Darktable, LMMS, Ardour |\\n | **🎮 Game Development** | Manage game projects, scenes, exports, and scripting through headless engine interfaces | **[Godot Engine](https://godotengine.org)**, **[s&box](https://sbox.game)** |\\n | **🔬 Scientific Computing** | Automate research workflows, simulations, and complex calculations | ImageJ, FreeCAD, QGIS, ParaView, Gephi, LibreCAD, Stellarium, KiCad, JASP, Jamovi |\\n | **🏢 Enterprise & Office** | Convert business applications and productivity tools into agent-accessible systems | NextCloud, GitLab, Grafana, Mattermost, LibreOffice, AppFlowy, NocoDB, Odoo (Community), Plane, ERPNext |\\n@@ -943,6 +943,13 @@ Each application received complete, production-ready CLI interfaces — not demo\\n <td align=\\\"center\\\">✅ 161</td>\\n </tr>\\n <tr>\\n+<td align=\\\"center\\\"><strong>WaveTone</strong></td>\\n+<td>Audio Transcription</td>\\n+<td><code>cli-anything-wavetone</code></td>\\n+<td>JSON manifest + real WaveTone launch</td>\\n+<td align=\\\"center\\\"><a href=\\\"wavetone/agent-harness/\\\">New</a></td>\\n+</tr>\\n+<tr>\\n <td align=\\\"center\\\"><strong>🌐 Browser</strong></td>\\n <td>Browser Automation</td>\\n <td><code>cli-anything-browser</code></td>\\n@@ -1221,6 +1228,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\\n blender 208 passed ✅ (150 unit + 58 e2e)\\n inkscape 202 passed ✅ (148 unit + 54 e2e)\\n audacity 161 passed ✅ (107 unit + 54 e2e)\\n+wavetone 30 passed ✅ (24 unit + 6 default e2e, 2 backend-gated e2e skipped; 32 passed opt-in)\\n libreoffice 158 passed ✅ (89 unit + 69 e2e)\\n mubu 96 passed ✅ (85 unit + 11 e2e)\\n obs-studio 153 passed ✅ (116 unit + 37 e2e)\\n@@ -1300,6 +1308,7 @@ cli-anything/\\n ├── 🧊 blender/agent-harness/ # Blender CLI (208 tests)\\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI (202 tests)\\n ├── 🎵 audacity/agent-harness/ # Audacity CLI (161 tests)\\n+├── wavetone/agent-harness/ # WaveTone CLI (32 tests: 30 default + 2 backend-gated e2e)\\n ├── 🌐 browser/agent-harness/ # Browser CLI (DOMShell MCP, new)\\n ├── 📄 libreoffice/agent-harness/ # LibreOffice CLI (158 tests)\\n ├── 📧 mailchimp/agent-harness/ # Mailchimp Marketing API CLI (303 commands, 36 unit tests)\\n\"\n },\n {\n \"comment\": \"The WaveTone test counts here likely need to be updated to match the harness test suite and `cli_anything/wavetone/tests/TEST.md` (9 unit + 5 E2E = 14).\",\n \"path\": \"README_CN.md\",\n \"hunk\": \"@@ -672,6 +679,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\\n blender 208 passed ✅ (150 unit + 58 e2e)\\n inkscape 202 passed ✅ (148 unit + 54 e2e)\\n audacity 161 passed ✅ (107 unit + 54 e2e)\\n+wavetone 13 passed ✅ (8 unit + 5 e2e)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/README_CN.md b/README_CN.md\\nindex ffac02dd9..6434d70e0 100644\\n--- a/README_CN.md\\n+++ b/README_CN.md\\n@@ -368,7 +368,7 @@ cli-anything-gimp\\n | **🤖 AI/ML 平台** | 用结构化命令驱动模型训练、推理流水线和超参搜索 | Stable Diffusion WebUI、ComfyUI、InvokeAI、Text-generation-webui、Open WebUI、Fooocus、Kohya_ss、AnythingLLM、SillyTavern |\\n | **📊 数据与分析** | 以编程方式完成数据处理、可视化和统计分析工作流 | JupyterLab、Apache Superset、Metabase、Redash、DBeaver、KNIME、Orange、OpenSearch Dashboards、Lightdash |\\n | **💻 开发工具** | 通过 CLI 串联代码编辑、构建、测试与部署流程 | Jenkins、Gitea、Hoppscotch、Portainer、pgAdmin、SonarQube、ArgoCD、OpenLens、Insomnia、Beekeeper Studio |\\n-| **🎨 创意与媒体** | 以编程方式控制内容创作、编辑和渲染工作流 | Blender、GIMP、OBS Studio、Audacity、Krita、Kdenlive、Shotcut、Inkscape、Darktable、LMMS、Ardour |\\n+| **🎨 创意与媒体** | 以编程方式控制内容创作、编辑和渲染工作流 | Blender、GIMP、OBS Studio、Audacity、WaveTone、Krita、Kdenlive、Shotcut、Inkscape、Darktable、LMMS、Ardour |\\n | **📐 图表与可视化** | 以编程方式创建和操作流程图、架构图、ER 图等各类图表 | Draw.io (diagrams.net)、Mermaid、PlantUML、Excalidraw、yEd |\\n | **🔬 科学计算** | 自动化科研工作流、仿真模拟和复杂计算 | ImageJ、FreeCAD、QGIS、ParaView、Gephi、LibreCAD、Stellarium、KiCad、JASP、Jamovi |\\n | **🏢 企业与办公** | 将商业应用和生产力工具转化为 Agent 可访问的系统 | NextCloud、GitLab、Grafana、Mattermost、LibreOffice、AppFlowy、NocoDB、Odoo (Community)、Plane、ERPNext |\\n@@ -534,6 +534,13 @@ CLI-Anything 适用于任何有代码库的软件 —— 不限领域，不限\\n <td align=\\\"center\\\">✅ 161</td>\\n </tr>\\n <tr>\\n+<td align=\\\"center\\\"><strong>WaveTone</strong></td>\\n+<td>音频扒谱辅助</td>\\n+<td><code>cli-anything-wavetone</code></td>\\n+<td>JSON manifest + real WaveTone launch</td>\\n+<td align=\\\"center\\\"><a href=\\\"wavetone/agent-harness/\\\">新增</a></td>\\n+</tr>\\n+<tr>\\n <td align=\\\"center\\\"><strong>📄 LibreOffice</strong></td>\\n <td>办公套件（Writer、Calc、Impress）</td>\\n <td><code>cli-anything-libreoffice</code></td>\\n@@ -672,6 +679,7 @@ gimp 107 passed ✅ (64 unit + 43 e2e)\\n blender 208 passed ✅ (150 unit + 58 e2e)\\n inkscape 202 passed ✅ (148 unit + 54 e2e)\\n audacity 161 passed ✅ (107 unit + 54 e2e)\\n+wavetone 30 passed ✅ (24 unit + 6 default e2e，2 backend-gated e2e skipped；32 passed opt-in)\\n libreoffice 158 passed ✅ (89 unit + 69 e2e)\\n obs-studio 153 passed ✅ (116 unit + 37 e2e)\\n kdenlive 155 passed ✅ (111 unit + 44 e2e)\\n@@ -745,6 +753,7 @@ cli-anything/\\n ├── 🧊 blender/agent-harness/ # Blender CLI（208 项测试）\\n ├── ✏️ inkscape/agent-harness/ # Inkscape CLI（202 项测试）\\n ├── 🎵 audacity/agent-harness/ # Audacity CLI（161 项测试）\\n+├── wavetone/agent-harness/ # WaveTone CLI（32 项测试：30 default + 2 backend-gated e2e）\\n ├── 📄 libreoffice/agent-harness/ # LibreOffice CLI（158 项测试）\\n ├── 📚 zotero/agent-harness/ # Zotero CLI（新增，支持文献导入）\\n ├── 📓 joplin/agent-harness/ # Joplin CLI（134 测试：107 单元 + 27 e2e）\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Preserve inherited JSON mode in nested CLI calls**\\n\\nWhen the REPL is launched with `cli-anything-wavetone --json`, each command entered inside the REPL is re-dispatched via `cli.main(..., obj=ctx.obj)` without a `--json` option, so `json_mode` is `False` and this assignment overwrites the inherited JSON setting. In that scenario, commands like `defaults` or `audio probe` emit the human-readable `key: value` format instead of machine-readable JSON despite the REPL being started in JSON mode; only replace `ctx.obj[\\\"json\\\"]` when the option was explicitly provided, or preserve the existing value for nested invocations.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,347 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ ctx.obj[\\\"json\\\"] = json_mode\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Handle EOFError from malformed WAV files**\\n\\nFor empty or truncated `.wav`/`.wave` inputs, `wave.open()` can raise `EOFError` rather than `wave.Error`; in that case `probe_audio()` bypasses the ffprobe/stat fallback and the CLI exits as an abort even in `--json` mode. This affects existing files with a supported WAV extension whose header is incomplete, so include `EOFError` in the fallback path or convert it to a Click error.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/audio.py\",\n \"hunk\": \"@@ -0,0 +1,96 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"format=duration,format_name,bit_rate,size\\\",\\n+ \\\"-of\\\",\\n+ \\\"json\\\",\\n+ str(path),\\n+ ],\\n+ capture_output=True,\\n+ text=True,\\n+ check=True,\\n+ )\\n+ data = json.loads(result.stdout)\\n+ audio_stream = next(\\n+ (stream for stream in data.get(\\\"streams\\\", []) if stream.get(\\\"codec_type\\\") == \\\"audio\\\"),\\n+ {},\\n+ )\\n+ fmt = data.get(\\\"format\\\", {})\\n+ duration = float(fmt.get(\\\"duration\\\") or 0.0)\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": fmt.get(\\\"format_name\\\"),\\n+ \\\"codec\\\": audio_stream.get(\\\"codec_name\\\"),\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": int(audio_stream[\\\"sample_rate\\\"]) if audio_stream.get(\\\"sample_rate\\\") else None,\\n+ \\\"channels\\\": audio_stream.get(\\\"channels\\\"),\\n+ \\\"bit_rate\\\": int(fmt[\\\"bit_rate\\\"]) if fmt.get(\\\"bit_rate\\\") else None,\\n+ \\\"size_bytes\\\": int(fmt.get(\\\"size\\\") or path.stat().st_size),\\n+ \\\"probe_method\\\": \\\"ffprobe\\\",\\n+ }\\n+\\n+\\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\\n+ path = normalize_audio_path(audio_path)\\n+ if path.suffix.lower() in {\\\".wav\\\", \\\".wave\\\"}:\\n+ try:\\n+ return _probe_wav_stdlib(path)\\n+ except wave.Error:\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\nnew file mode 100644\\nindex 000000000..f35f343f5\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\n@@ -0,0 +1,112 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _safe_float(value: Any) -> float | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return float(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _safe_int(value: Any) -> int | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return int(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\\\",\\n+ \\\"-of\\\",\\n+ \\\"json\\\",\\n+ str(path),\\n+ ],\\n+ capture_output=True,\\n+ text=True,\\n+ check=True,\\n+ )\\n+ data = json.loads(result.stdout)\\n+ audio_stream = next(\\n+ (stream for stream in data.get(\\\"streams\\\", []) if stream.get(\\\"codec_type\\\") == \\\"audio\\\"),\\n+ {},\\n+ )\\n+ fmt = data.get(\\\"format\\\", {})\\n+ duration = _safe_float(fmt.get(\\\"duration\\\"))\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": fmt.get(\\\"format_name\\\"),\\n+ \\\"codec\\\": audio_stream.get(\\\"codec_name\\\"),\\n+ \\\"duration_seconds\\\": round(duration, 6) if duration is not None else None,\\n+ \\\"sample_rate\\\": _safe_int(audio_stream.get(\\\"sample_rate\\\")),\\n+ \\\"channels\\\": _safe_int(audio_stream.get(\\\"channels\\\")),\\n+ \\\"bit_rate\\\": _safe_int(fmt.get(\\\"bit_rate\\\")),\\n+ \\\"size_bytes\\\": _safe_int(fmt.get(\\\"size\\\")) or path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"ffprobe\\\",\\n+ }\\n+\\n+\\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\\n+ path = normalize_audio_path(audio_path)\\n+ if path.suffix.lower() in {\\\".wav\\\", \\\".wave\\\"}:\\n+ try:\\n+ return _probe_wav_stdlib(path)\\n+ except (wave.Error, EOFError):\\n+ pass\\n+ try:\\n+ return _probe_ffprobe(path)\\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": path.suffix.lower().lstrip(\\\".\\\") or None,\\n+ \\\"codec\\\": None,\\n+ \\\"duration_seconds\\\": None,\\n+ \\\"sample_rate\\\": None,\\n+ \\\"channels\\\": None,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"stat\\\",\\n+ \\\"warning\\\": \\\"Install ffprobe for detailed metadata on this format.\\\",\\n+ }\\n\"\n },\n {\n \"comment\": \"`ffprobe`’s `-show_entries` is typically provided once (with multiple sections separated by `:`). Passing it twice can result in only the latter taking effect on some ffprobe builds, which would make `streams` missing and break the `audio_stream` extraction. Combine the entries into a single `-show_entries` argument (e.g., `stream=...:format=...`) to make the probe reliable.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/audio.py\",\n \"hunk\": \"@@ -0,0 +1,96 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"format=duration,format_name,bit_rate,size\\\",\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\nnew file mode 100644\\nindex 000000000..f35f343f5\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\n@@ -0,0 +1,112 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _safe_float(value: Any) -> float | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return float(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _safe_int(value: Any) -> int | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return int(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\\\",\\n+ \\\"-of\\\",\\n+ \\\"json\\\",\\n+ str(path),\\n+ ],\\n+ capture_output=True,\\n+ text=True,\\n+ check=True,\\n+ )\\n+ data = json.loads(result.stdout)\\n+ audio_stream = next(\\n+ (stream for stream in data.get(\\\"streams\\\", []) if stream.get(\\\"codec_type\\\") == \\\"audio\\\"),\\n+ {},\\n+ )\\n+ fmt = data.get(\\\"format\\\", {})\\n+ duration = _safe_float(fmt.get(\\\"duration\\\"))\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": fmt.get(\\\"format_name\\\"),\\n+ \\\"codec\\\": audio_stream.get(\\\"codec_name\\\"),\\n+ \\\"duration_seconds\\\": round(duration, 6) if duration is not None else None,\\n+ \\\"sample_rate\\\": _safe_int(audio_stream.get(\\\"sample_rate\\\")),\\n+ \\\"channels\\\": _safe_int(audio_stream.get(\\\"channels\\\")),\\n+ \\\"bit_rate\\\": _safe_int(fmt.get(\\\"bit_rate\\\")),\\n+ \\\"size_bytes\\\": _safe_int(fmt.get(\\\"size\\\")) or path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"ffprobe\\\",\\n+ }\\n+\\n+\\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\\n+ path = normalize_audio_path(audio_path)\\n+ if path.suffix.lower() in {\\\".wav\\\", \\\".wave\\\"}:\\n+ try:\\n+ return _probe_wav_stdlib(path)\\n+ except (wave.Error, EOFError):\\n+ pass\\n+ try:\\n+ return _probe_ffprobe(path)\\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": path.suffix.lower().lstrip(\\\".\\\") or None,\\n+ \\\"codec\\\": None,\\n+ \\\"duration_seconds\\\": None,\\n+ \\\"sample_rate\\\": None,\\n+ \\\"channels\\\": None,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"stat\\\",\\n+ \\\"warning\\\": \\\"Install ffprobe for detailed metadata on this format.\\\",\\n+ }\\n\"\n },\n {\n \"comment\": \"If the existing session file contains valid JSON that is not an object (e.g., a list/string/number), `data.setdefault(...)` will raise `AttributeError`, which is not caught by the CLI handlers (they catch `ValueError`/`JSONDecodeError`). Validate `data` is a `dict` (and that `events` is a list) after `json.loads`, and raise a `ValueError` with a clear message when the schema is invalid.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/session.py\",\n \"hunk\": \"@@ -0,0 +1,30 @@\\n+\\\"\\\"\\\"Small session event log for WaveTone CLI runs.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import now_iso\\n+\\n+\\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ if path.exists():\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ else:\\n+ data = {\\\"schema_version\\\": \\\"wavetone-session/v1\\\", \\\"events\\\": []}\\n+ record = {\\\"time\\\": now_iso(), \\\"event\\\": event, \\\"payload\\\": payload}\\n+ data.setdefault(\\\"events\\\", []).append(record)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/session.py b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\\nnew file mode 100644\\nindex 000000000..d9f2c7f26\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\\n@@ -0,0 +1,61 @@\\n+\\\"\\\"\\\"Small session event log for WaveTone CLI runs.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import now_iso\\n+\\n+\\n+def _new_session() -> dict[str, Any]:\\n+ return {\\\"schema_version\\\": \\\"wavetone-session/v1\\\", \\\"events\\\": []}\\n+\\n+\\n+def _assert_json_safe(value: Any, path: str = \\\"payload\\\") -> None:\\n+ if isinstance(value, float) and not math.isfinite(value):\\n+ raise ValueError(f\\\"{path} must contain only finite numbers\\\")\\n+ if isinstance(value, dict):\\n+ for key, item in value.items():\\n+ _assert_json_safe(item, f\\\"{path}.{key}\\\")\\n+ elif isinstance(value, list):\\n+ for idx, item in enumerate(value):\\n+ _assert_json_safe(item, f\\\"{path}[{idx}]\\\")\\n+\\n+\\n+def _load_session_data(path: Path) -> dict[str, Any]:\\n+ if not path.exists():\\n+ return _new_session()\\n+\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if not isinstance(data, dict):\\n+ raise ValueError(\\\"Session file must be a JSON object\\\")\\n+\\n+ events = data.get(\\\"events\\\")\\n+ if events is None:\\n+ data[\\\"events\\\"] = []\\n+ elif not isinstance(events, list):\\n+ raise ValueError(\\\"Session file field 'events' must be a list\\\")\\n+\\n+ return data\\n+\\n+\\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ data = _load_session_data(path)\\n+ _assert_json_safe(payload)\\n+ record = {\\\"time\\\": now_iso(), \\\"event\\\": event, \\\"payload\\\": payload}\\n+ data[\\\"events\\\"].append(record)\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return record\\n+\\n+\\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ if not path.exists():\\n+ return []\\n+ data = _load_session_data(path)\\n+ return list(data[\\\"events\\\"])\\n\"\n },\n {\n \"comment\": \"Similar to `append_event`, if the session JSON is valid but not a dict, `data.get(...)` will raise `AttributeError`, which again won’t be converted into a `click.ClickException` by callers that only catch `ValueError`/`JSONDecodeError`. Add a type/schema check after loading and raise `ValueError` when the structure is not `{ \\\"events\\\": [...] }`.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/session.py\",\n \"hunk\": \"@@ -0,0 +1,30 @@\\n+\\\"\\\"\\\"Small session event log for WaveTone CLI runs.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import now_iso\\n+\\n+\\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ if path.exists():\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ else:\\n+ data = {\\\"schema_version\\\": \\\"wavetone-session/v1\\\", \\\"events\\\": []}\\n+ record = {\\\"time\\\": now_iso(), \\\"event\\\": event, \\\"payload\\\": payload}\\n+ data.setdefault(\\\"events\\\", []).append(record)\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return record\\n+\\n+\\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ if not path.exists():\\n+ return []\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ return list(data.get(\\\"events\\\", []))\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/session.py b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\\nnew file mode 100644\\nindex 000000000..d9f2c7f26\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\\n@@ -0,0 +1,61 @@\\n+\\\"\\\"\\\"Small session event log for WaveTone CLI runs.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import now_iso\\n+\\n+\\n+def _new_session() -> dict[str, Any]:\\n+ return {\\\"schema_version\\\": \\\"wavetone-session/v1\\\", \\\"events\\\": []}\\n+\\n+\\n+def _assert_json_safe(value: Any, path: str = \\\"payload\\\") -> None:\\n+ if isinstance(value, float) and not math.isfinite(value):\\n+ raise ValueError(f\\\"{path} must contain only finite numbers\\\")\\n+ if isinstance(value, dict):\\n+ for key, item in value.items():\\n+ _assert_json_safe(item, f\\\"{path}.{key}\\\")\\n+ elif isinstance(value, list):\\n+ for idx, item in enumerate(value):\\n+ _assert_json_safe(item, f\\\"{path}[{idx}]\\\")\\n+\\n+\\n+def _load_session_data(path: Path) -> dict[str, Any]:\\n+ if not path.exists():\\n+ return _new_session()\\n+\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if not isinstance(data, dict):\\n+ raise ValueError(\\\"Session file must be a JSON object\\\")\\n+\\n+ events = data.get(\\\"events\\\")\\n+ if events is None:\\n+ data[\\\"events\\\"] = []\\n+ elif not isinstance(events, list):\\n+ raise ValueError(\\\"Session file field 'events' must be a list\\\")\\n+\\n+ return data\\n+\\n+\\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ data = _load_session_data(path)\\n+ _assert_json_safe(payload)\\n+ record = {\\\"time\\\": now_iso(), \\\"event\\\": event, \\\"payload\\\": payload}\\n+ data[\\\"events\\\"].append(record)\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return record\\n+\\n+\\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ if not path.exists():\\n+ return []\\n+ data = _load_session_data(path)\\n+ return list(data[\\\"events\\\"])\\n\"\n },\n {\n \"comment\": \"`find_namespace_packages(include=[\\\"cli_anything.*\\\"])` will also package `cli_anything.wavetone.tests` because it has an `__init__.py`. Shipping tests in the installable distribution is usually undesirable (larger wheels, extra dependencies, and accidental import surface). Exclude the test package (and any other non-runtime packages) via `exclude=[...]` or by tightening the include patterns.\",\n \"path\": \"wavetone/agent-harness/setup.py\",\n \"hunk\": \"@@ -0,0 +1,46 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\\n+\\n+setup(\\n+ name=\\\"cli-anything-wavetone\\\",\\n+ version=\\\"1.0.0\\\",\\n+ author=\\\"cli-anything contributors\\\",\\n+ description=(\\n+ \\\"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \\\"\\n+ \\\"analysis manifests and launches the real WaveTone Windows executable.\\\"\\n+ ),\\n+ long_description=readme.read_text(encoding=\\\"utf-8\\\") if readme.exists() else \\\"\\\",\\n+ long_description_content_type=\\\"text/markdown\\\",\\n+ url=\\\"https://github.com/HKUDS/CLI-Anything\\\",\\n+ packages=find_namespace_packages(include=[\\\"cli_anything.*\\\"]),\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\\nnew file mode 100644\\nindex 000000000..4821f34d0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/setup.py\\n@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\\n+\\n+setup(\\n+ name=\\\"cli-anything-wavetone\\\",\\n+ version=\\\"1.0.0\\\",\\n+ author=\\\"cli-anything contributors\\\",\\n+ description=(\\n+ \\\"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \\\"\\n+ \\\"analysis manifests and launches the real WaveTone Windows executable.\\\"\\n+ ),\\n+ long_description=readme.read_text(encoding=\\\"utf-8\\\") if readme.exists() else \\\"\\\",\\n+ long_description_content_type=\\\"text/markdown\\\",\\n+ url=\\\"https://github.com/HKUDS/CLI-Anything\\\",\\n+ packages=find_namespace_packages(\\n+ include=[\\\"cli_anything.*\\\"],\\n+ exclude=[\\\"cli_anything.*.tests\\\", \\\"cli_anything.*.tests.*\\\"],\\n+ ),\\n+ classifiers=[\\n+ \\\"Development Status :: 4 - Beta\\\",\\n+ \\\"Intended Audience :: Developers\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Analysis\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Editors\\\",\\n+ \\\"License :: OSI Approved :: MIT License\\\",\\n+ \\\"Programming Language :: Python :: 3\\\",\\n+ \\\"Programming Language :: Python :: 3.10\\\",\\n+ \\\"Programming Language :: Python :: 3.11\\\",\\n+ \\\"Programming Language :: Python :: 3.12\\\",\\n+ \\\"Operating System :: Microsoft :: Windows\\\",\\n+ ],\\n+ python_requires=\\\">=3.10\\\",\\n+ install_requires=[\\\"click>=8.0.0\\\", \\\"prompt-toolkit>=3.0.0\\\"],\\n+ extras_require={\\\"dev\\\": [\\\"pytest>=7.0.0\\\"]},\\n+ entry_points={\\n+ \\\"console_scripts\\\": [\\n+ \\\"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\\\",\\n+ ],\\n+ },\\n+ package_data={\\\"cli_anything.wavetone\\\": [\\\"README.md\\\", \\\"skills/SKILL.md\\\", \\\"skills/*.md\\\"]},\\n+ include_package_data=True,\\n+ zip_safe=False,\\n+)\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Fail launch smoke checks on early process exit**\\n\\nWhen `wavetone launch --wait ...` is used as the documented smoke check and the executable starts but immediately exits (for example because a bundled DLL is missing or the GUI fails during startup), `launch_wavetone()` returns `running_after_wait: false` and the nonzero `exit_code`, but this wrapper still emits `ok: True` and exits 0 unconditionally. I reproduced this with a fake `wavetone.exe` that exits 42; CI or agents relying on the recommended launch command's exit status would accept a failed backend launch instead of surfacing it.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,350 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"wavetone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = shlex.split(line, posix=(os.name != \\\"nt\\\"))\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental/--no-fundamental\\\", default=None)\\n+@click.option(\\\"--skip-dialog/--show-dialog\\\", default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"launch\\\": data}, ctx_json(ctx))\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"`ffprobe` commonly returns `\\\"N/A\\\"` (or other non-numeric strings) for fields like `duration`, `bit_rate`, `size`, and `sample_rate`. As written, `float(...)` / `int(...)` can raise `ValueError`, which is not caught by `probe_audio()` (it only catches `RuntimeError`, `CalledProcessError`, `JSONDecodeError`), causing the CLI to fail unexpectedly. Consider adding safe numeric parsing (e.g., helper that returns `None` for missing/invalid values, including `\\\"N/A\\\"`) and/or expanding the caller’s exception handling so invalid numeric fields fall back to `\\\"stat\\\"` probing rather than crashing.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/audio.py\",\n \"hunk\": \"@@ -0,0 +1,94 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\\\",\\n+ \\\"-of\\\",\\n+ \\\"json\\\",\\n+ str(path),\\n+ ],\\n+ capture_output=True,\\n+ text=True,\\n+ check=True,\\n+ )\\n+ data = json.loads(result.stdout)\\n+ audio_stream = next(\\n+ (stream for stream in data.get(\\\"streams\\\", []) if stream.get(\\\"codec_type\\\") == \\\"audio\\\"),\\n+ {},\\n+ )\\n+ fmt = data.get(\\\"format\\\", {})\\n+ duration = float(fmt.get(\\\"duration\\\") or 0.0)\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": fmt.get(\\\"format_name\\\"),\\n+ \\\"codec\\\": audio_stream.get(\\\"codec_name\\\"),\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": int(audio_stream[\\\"sample_rate\\\"]) if audio_stream.get(\\\"sample_rate\\\") else None,\\n+ \\\"channels\\\": audio_stream.get(\\\"channels\\\"),\\n+ \\\"bit_rate\\\": int(fmt[\\\"bit_rate\\\"]) if fmt.get(\\\"bit_rate\\\") else None,\\n+ \\\"size_bytes\\\": int(fmt.get(\\\"size\\\") or path.stat().st_size),\\n+ \\\"probe_method\\\": \\\"ffprobe\\\",\\n+ }\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\nnew file mode 100644\\nindex 000000000..f35f343f5\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\n@@ -0,0 +1,112 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _safe_float(value: Any) -> float | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return float(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _safe_int(value: Any) -> int | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return int(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\\\",\\n+ \\\"-of\\\",\\n+ \\\"json\\\",\\n+ str(path),\\n+ ],\\n+ capture_output=True,\\n+ text=True,\\n+ check=True,\\n+ )\\n+ data = json.loads(result.stdout)\\n+ audio_stream = next(\\n+ (stream for stream in data.get(\\\"streams\\\", []) if stream.get(\\\"codec_type\\\") == \\\"audio\\\"),\\n+ {},\\n+ )\\n+ fmt = data.get(\\\"format\\\", {})\\n+ duration = _safe_float(fmt.get(\\\"duration\\\"))\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": fmt.get(\\\"format_name\\\"),\\n+ \\\"codec\\\": audio_stream.get(\\\"codec_name\\\"),\\n+ \\\"duration_seconds\\\": round(duration, 6) if duration is not None else None,\\n+ \\\"sample_rate\\\": _safe_int(audio_stream.get(\\\"sample_rate\\\")),\\n+ \\\"channels\\\": _safe_int(audio_stream.get(\\\"channels\\\")),\\n+ \\\"bit_rate\\\": _safe_int(fmt.get(\\\"bit_rate\\\")),\\n+ \\\"size_bytes\\\": _safe_int(fmt.get(\\\"size\\\")) or path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"ffprobe\\\",\\n+ }\\n+\\n+\\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\\n+ path = normalize_audio_path(audio_path)\\n+ if path.suffix.lower() in {\\\".wav\\\", \\\".wave\\\"}:\\n+ try:\\n+ return _probe_wav_stdlib(path)\\n+ except (wave.Error, EOFError):\\n+ pass\\n+ try:\\n+ return _probe_ffprobe(path)\\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": path.suffix.lower().lstrip(\\\".\\\") or None,\\n+ \\\"codec\\\": None,\\n+ \\\"duration_seconds\\\": None,\\n+ \\\"sample_rate\\\": None,\\n+ \\\"channels\\\": None,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"stat\\\",\\n+ \\\"warning\\\": \\\"Install ffprobe for detailed metadata on this format.\\\",\\n+ }\\n\"\n },\n {\n \"comment\": \"The packaged skill file is `skills/SKILL.md` (uppercase extension). On case-sensitive filesystems (common for Linux build agents), the glob `skills/*.md` will not match `SKILL.md`, so the skill file won’t be included in wheels/sdists. Include the exact filename (e.g., `skills/SKILL.md`) and/or broaden the pattern to cover both cases so agents relying on packaged skill discovery don’t lose the documentation.\",\n \"path\": \"wavetone/agent-harness/setup.py\",\n \"hunk\": \"@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\\n+\\n+setup(\\n+ name=\\\"cli-anything-wavetone\\\",\\n+ version=\\\"1.0.0\\\",\\n+ author=\\\"cli-anything contributors\\\",\\n+ description=(\\n+ \\\"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \\\"\\n+ \\\"analysis manifests and launches the real WaveTone Windows executable.\\\"\\n+ ),\\n+ long_description=readme.read_text(encoding=\\\"utf-8\\\") if readme.exists() else \\\"\\\",\\n+ long_description_content_type=\\\"text/markdown\\\",\\n+ url=\\\"https://github.com/HKUDS/CLI-Anything\\\",\\n+ packages=find_namespace_packages(\\n+ include=[\\\"cli_anything.*\\\"],\\n+ exclude=[\\\"cli_anything.*.tests\\\", \\\"cli_anything.*.tests.*\\\"],\\n+ ),\\n+ classifiers=[\\n+ \\\"Development Status :: 4 - Beta\\\",\\n+ \\\"Intended Audience :: Developers\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Analysis\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Editors\\\",\\n+ \\\"License :: OSI Approved :: MIT License\\\",\\n+ \\\"Programming Language :: Python :: 3\\\",\\n+ \\\"Programming Language :: Python :: 3.10\\\",\\n+ \\\"Programming Language :: Python :: 3.11\\\",\\n+ \\\"Programming Language :: Python :: 3.12\\\",\\n+ \\\"Operating System :: Microsoft :: Windows\\\",\\n+ ],\\n+ python_requires=\\\">=3.10\\\",\\n+ install_requires=[\\\"click>=8.0.0\\\", \\\"prompt-toolkit>=3.0.0\\\"],\\n+ extras_require={\\\"dev\\\": [\\\"pytest>=7.0.0\\\"]},\\n+ entry_points={\\n+ \\\"console_scripts\\\": [\\n+ \\\"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\\\",\\n+ ],\\n+ },\\n+ package_data={\\\"cli_anything.wavetone\\\": [\\\"skills/*.md\\\"]},\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\\nnew file mode 100644\\nindex 000000000..4821f34d0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/setup.py\\n@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\\n+\\n+setup(\\n+ name=\\\"cli-anything-wavetone\\\",\\n+ version=\\\"1.0.0\\\",\\n+ author=\\\"cli-anything contributors\\\",\\n+ description=(\\n+ \\\"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \\\"\\n+ \\\"analysis manifests and launches the real WaveTone Windows executable.\\\"\\n+ ),\\n+ long_description=readme.read_text(encoding=\\\"utf-8\\\") if readme.exists() else \\\"\\\",\\n+ long_description_content_type=\\\"text/markdown\\\",\\n+ url=\\\"https://github.com/HKUDS/CLI-Anything\\\",\\n+ packages=find_namespace_packages(\\n+ include=[\\\"cli_anything.*\\\"],\\n+ exclude=[\\\"cli_anything.*.tests\\\", \\\"cli_anything.*.tests.*\\\"],\\n+ ),\\n+ classifiers=[\\n+ \\\"Development Status :: 4 - Beta\\\",\\n+ \\\"Intended Audience :: Developers\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Analysis\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Editors\\\",\\n+ \\\"License :: OSI Approved :: MIT License\\\",\\n+ \\\"Programming Language :: Python :: 3\\\",\\n+ \\\"Programming Language :: Python :: 3.10\\\",\\n+ \\\"Programming Language :: Python :: 3.11\\\",\\n+ \\\"Programming Language :: Python :: 3.12\\\",\\n+ \\\"Operating System :: Microsoft :: Windows\\\",\\n+ ],\\n+ python_requires=\\\">=3.10\\\",\\n+ install_requires=[\\\"click>=8.0.0\\\", \\\"prompt-toolkit>=3.0.0\\\"],\\n+ extras_require={\\\"dev\\\": [\\\"pytest>=7.0.0\\\"]},\\n+ entry_points={\\n+ \\\"console_scripts\\\": [\\n+ \\\"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\\\",\\n+ ],\\n+ },\\n+ package_data={\\\"cli_anything.wavetone\\\": [\\\"README.md\\\", \\\"skills/SKILL.md\\\", \\\"skills/*.md\\\"]},\\n+ include_package_data=True,\\n+ zip_safe=False,\\n+)\\n\"\n },\n {\n \"comment\": \"This harness is documented as Windows-only, but `launch_wavetone()` will attempt `subprocess.Popen()` on any platform and then fail with a low-level OS error (e.g., exec format error). Adding an explicit platform guard (similar to `doctor()`’s Windows check) and raising a clear exception (e.g., `RuntimeError(\\\"WaveTone launch requires Windows\\\")`) will make failures more actionable in CI/non-Windows environments.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\",\n \"hunk\": \"@@ -0,0 +1,160 @@\\n+\\\"\\\"\\\"Backend wrapper for the real WaveTone 2.61 executable.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import os\\n+import platform\\n+import subprocess\\n+import time\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\\n+\\n+\\n+REQUIRED_DATA_FILES = [\\n+ \\\"awlib.dll\\\",\\n+ \\\"bass.dll\\\",\\n+ \\\"bassflac.dll\\\",\\n+ \\\"basswma.dll\\\",\\n+ \\\"basswv.dll\\\",\\n+ \\\"bass_aac.dll\\\",\\n+ \\\"bass_alac.dll\\\",\\n+ \\\"bass_ape.dll\\\",\\n+ \\\"bass_tta.dll\\\",\\n+ \\\"asdecoder.exe\\\",\\n+]\\n+\\n+\\n+def default_candidates() -> list[Path]:\\n+ candidates: list[Path] = []\\n+ env_exe = os.environ.get(\\\"WAVETONE_EXE\\\")\\n+ if env_exe:\\n+ candidates.append(Path(env_exe))\\n+ env_home = os.environ.get(\\\"WAVETONE_HOME\\\")\\n+ if env_home:\\n+ candidates.append(Path(env_home) / \\\"wavetone.exe\\\")\\n+ candidates.append(Path(env_home) / \\\"WaveTone.exe\\\")\\n+ home = Path.home()\\n+ candidates.extend(\\n+ [\\n+ home / \\\"Desktop\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ home / \\\"Downloads\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ Path(\\\"C:/Program Files/WaveTone/wavetone.exe\\\"),\\n+ Path(\\\"C:/Program Files (x86)/WaveTone/wavetone.exe\\\"),\\n+ ]\\n+ )\\n+ return candidates\\n+\\n+\\n+def find_wavetone(executable: str | Path | None = None) -> Path:\\n+ candidates = [Path(executable)] if executable else default_candidates()\\n+ checked: list[str] = []\\n+ for candidate in candidates:\\n+ path = candidate.expanduser()\\n+ checked.append(str(path))\\n+ if path.exists() and path.is_file():\\n+ return path.resolve()\\n+ raise FileNotFoundError(\\n+ \\\"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \\\"\\n+ \\\"WAVETONE_HOME to the extracted WaveTone directory. Checked: \\\"\\n+ + \\\"; \\\".join(checked)\\n+ )\\n+\\n+\\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\\n+ checks: list[dict[str, Any]] = []\\n+ try:\\n+ exe = find_wavetone(executable)\\n+ root = exe.parent\\n+ checks.append({\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": True, \\\"path\\\": str(exe)})\\n+ except FileNotFoundError as exc:\\n+ return {\\n+ \\\"ready\\\": False,\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"checks\\\": [{\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": False, \\\"error\\\": str(exc)}],\\n+ }\\n+\\n+ data_dir = root / \\\"data\\\"\\n+ checks.append({\\\"name\\\": \\\"data directory\\\", \\\"ok\\\": data_dir.is_dir(), \\\"path\\\": str(data_dir)})\\n+ for filename in REQUIRED_DATA_FILES:\\n+ path = data_dir / filename\\n+ checks.append({\\\"name\\\": f\\\"data/{filename}\\\", \\\"ok\\\": path.exists(), \\\"path\\\": str(path)})\\n+ help_dir = root / \\\"wthelp\\\"\\n+ checks.append({\\\"name\\\": \\\"help directory\\\", \\\"ok\\\": help_dir.is_dir(), \\\"path\\\": str(help_dir)})\\n+ checks.append(\\n+ {\\n+ \\\"name\\\": \\\"windows host\\\",\\n+ \\\"ok\\\": platform.system().lower() == \\\"windows\\\",\\n+ \\\"platform\\\": platform.platform(),\\n+ }\\n+ )\\n+ return {\\n+ \\\"ready\\\": all(check[\\\"ok\\\"] for check in checks),\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"root\\\": str(root),\\n+ \\\"checks\\\": checks,\\n+ }\\n+\\n+\\n+def launch_wavetone(\\n+ audio_path: str | Path | None = None,\\n+ executable: str | Path | None = None,\\n+ wait_seconds: float = 0.0,\\n+ terminate: bool = False,\\n+) -> dict[str, Any]:\\n+ exe = find_wavetone(executable)\\n+ args = [str(exe)]\\n+ audio: Path | None = None\\n+ if audio_path:\\n+ audio = normalize_audio_path(audio_path)\\n+ args.append(str(audio))\\n+\\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\\nnew file mode 100644\\nindex 000000000..81d3d35ec\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\\n@@ -0,0 +1,163 @@\\n+\\\"\\\"\\\"Backend wrapper for the real WaveTone 2.61 executable.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import os\\n+import platform\\n+import subprocess\\n+import time\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\\n+\\n+\\n+REQUIRED_DATA_FILES = [\\n+ \\\"awlib.dll\\\",\\n+ \\\"bass.dll\\\",\\n+ \\\"bassflac.dll\\\",\\n+ \\\"basswma.dll\\\",\\n+ \\\"basswv.dll\\\",\\n+ \\\"bass_aac.dll\\\",\\n+ \\\"bass_alac.dll\\\",\\n+ \\\"bass_ape.dll\\\",\\n+ \\\"bass_tta.dll\\\",\\n+ \\\"asdecoder.exe\\\",\\n+]\\n+\\n+\\n+def default_candidates() -> list[Path]:\\n+ candidates: list[Path] = []\\n+ env_exe = os.environ.get(\\\"WAVETONE_EXE\\\")\\n+ if env_exe:\\n+ candidates.append(Path(env_exe))\\n+ env_home = os.environ.get(\\\"WAVETONE_HOME\\\")\\n+ if env_home:\\n+ candidates.append(Path(env_home) / \\\"wavetone.exe\\\")\\n+ candidates.append(Path(env_home) / \\\"WaveTone.exe\\\")\\n+ home = Path.home()\\n+ candidates.extend(\\n+ [\\n+ home / \\\"Desktop\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ home / \\\"Downloads\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ Path(\\\"C:/Program Files/WaveTone/wavetone.exe\\\"),\\n+ Path(\\\"C:/Program Files (x86)/WaveTone/wavetone.exe\\\"),\\n+ ]\\n+ )\\n+ return candidates\\n+\\n+\\n+def find_wavetone(executable: str | Path | None = None) -> Path:\\n+ candidates = [Path(executable)] if executable else default_candidates()\\n+ checked: list[str] = []\\n+ for candidate in candidates:\\n+ path = candidate.expanduser()\\n+ checked.append(str(path))\\n+ if path.exists() and path.is_file():\\n+ return path.resolve()\\n+ raise FileNotFoundError(\\n+ \\\"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \\\"\\n+ \\\"WAVETONE_HOME to the extracted WaveTone directory. Checked: \\\"\\n+ + \\\"; \\\".join(checked)\\n+ )\\n+\\n+\\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\\n+ checks: list[dict[str, Any]] = []\\n+ try:\\n+ exe = find_wavetone(executable)\\n+ root = exe.parent\\n+ checks.append({\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": True, \\\"path\\\": str(exe)})\\n+ except FileNotFoundError as exc:\\n+ return {\\n+ \\\"ready\\\": False,\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"checks\\\": [{\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": False, \\\"error\\\": str(exc)}],\\n+ }\\n+\\n+ data_dir = root / \\\"data\\\"\\n+ checks.append({\\\"name\\\": \\\"data directory\\\", \\\"ok\\\": data_dir.is_dir(), \\\"path\\\": str(data_dir)})\\n+ for filename in REQUIRED_DATA_FILES:\\n+ path = data_dir / filename\\n+ checks.append({\\\"name\\\": f\\\"data/{filename}\\\", \\\"ok\\\": path.is_file(), \\\"path\\\": str(path)})\\n+ help_dir = root / \\\"wthelp\\\"\\n+ checks.append({\\\"name\\\": \\\"help directory\\\", \\\"ok\\\": help_dir.is_dir(), \\\"path\\\": str(help_dir)})\\n+ checks.append(\\n+ {\\n+ \\\"name\\\": \\\"windows host\\\",\\n+ \\\"ok\\\": platform.system().lower() == \\\"windows\\\",\\n+ \\\"platform\\\": platform.platform(),\\n+ }\\n+ )\\n+ return {\\n+ \\\"ready\\\": all(check[\\\"ok\\\"] for check in checks),\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"root\\\": str(root),\\n+ \\\"checks\\\": checks,\\n+ }\\n+\\n+\\n+def launch_wavetone(\\n+ audio_path: str | Path | None = None,\\n+ executable: str | Path | None = None,\\n+ wait_seconds: float = 0.0,\\n+ terminate: bool = False,\\n+) -> dict[str, Any]:\\n+ if platform.system().lower() != \\\"windows\\\":\\n+ raise RuntimeError(\\\"WaveTone launch requires Windows\\\")\\n+\\n+ exe = find_wavetone(executable)\\n+ args = [str(exe)]\\n+ audio: Path | None = None\\n+ if audio_path:\\n+ audio = normalize_audio_path(audio_path)\\n+ args.append(str(audio))\\n+\\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\\n+ if wait_seconds > 0:\\n+ time.sleep(wait_seconds)\\n+ polled = process.poll()\\n+ running_after_wait = polled is None\\n+ exit_code = polled\\n+ terminated = False\\n+ if terminate and running_after_wait:\\n+ process.terminate()\\n+ try:\\n+ process.wait(timeout=3)\\n+ except subprocess.TimeoutExpired:\\n+ process.kill()\\n+ process.wait(timeout=3)\\n+ terminated = True\\n+ exit_code = process.returncode\\n+\\n+ return {\\n+ \\\"backend\\\": \\\"wavetone.exe\\\",\\n+ \\\"executable\\\": str(exe),\\n+ \\\"cwd\\\": str(exe.parent),\\n+ \\\"pid\\\": process.pid,\\n+ \\\"args\\\": args,\\n+ \\\"audio_path\\\": str(audio) if audio else None,\\n+ \\\"running_after_wait\\\": running_after_wait,\\n+ \\\"terminated\\\": terminated,\\n+ \\\"exit_code\\\": exit_code,\\n+ \\\"note\\\": \\\"WaveTone analysis and export dialogs are GUI driven in version 2.61.\\\",\\n+ }\\n+\\n+\\n+def supported_formats() -> dict[str, Any]:\\n+ return {\\n+ \\\"extensions\\\": sorted(SUPPORTED_AUDIO_EXTENSIONS),\\n+ \\\"from_readme\\\": [\\n+ \\\"WAVE\\\",\\n+ \\\"AIFF\\\",\\n+ \\\"MP3\\\",\\n+ \\\"WMA\\\",\\n+ \\\"AAC\\\",\\n+ \\\"Vorbis\\\",\\n+ \\\"FLAC\\\",\\n+ \\\"WavPack\\\",\\n+ \\\"Monkey's Audio\\\",\\n+ \\\"ALAC\\\",\\n+ \\\"TTA\\\",\\n+ ],\\n+ }\\n\"\n },\n {\n \"comment\": \"`make_wav()` is duplicated in `test_core.py` and `test_full_e2e.py` with slightly different defaults. To reduce duplication and keep fixtures consistent, consider moving it into a shared test utility module or a pytest fixture and importing it from both test files.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\",\n \"hunk\": \"@@ -0,0 +1,137 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+import os\\n+import shutil\\n+import struct\\n+import subprocess\\n+import sys\\n+import wave\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+\\n+def make_wav(path: Path, freq: float = 440.0, duration: float = 0.5, sample_rate: int = 8000) -> Path:\\n+ frames = int(duration * sample_rate)\\n+ with wave.open(str(path), \\\"wb\\\") as handle:\\n+ handle.setnchannels(1)\\n+ handle.setsampwidth(2)\\n+ handle.setframerate(sample_rate)\\n+ for idx in range(frames):\\n+ sample = int(16000 * math.sin(2 * math.pi * freq * idx / sample_rate))\\n+ handle.writeframes(struct.pack(\\\"<h\\\", sample))\\n+ return path\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\nnew file mode 100644\\nindex 000000000..2ceb45661\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\n@@ -0,0 +1,153 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shutil\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.tests.helpers import make_wav\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+REAL_BACKEND_ENV = \\\"CLI_ANYTHING_WAVETONE_REAL_BACKEND\\\"\\n+\\n+\\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\\n+ \\\"\\\"\\\"Run the in-tree module by default; installed entry points are opt-in.\\\"\\\"\\\"\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ if not force_installed:\\n+ print(f\\\"[_resolve_cli] Using source module: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+ path = shutil.which(name)\\n+ if not path:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+\\n+\\n+def _env_flag_enabled(name: str) -> bool:\\n+ return os.environ.get(name, \\\"\\\").strip().lower() in {\\\"1\\\", \\\"true\\\", \\\"yes\\\", \\\"on\\\"}\\n+\\n+\\n+def _real_backend_ready() -> tuple[bool, str]:\\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\\n+ return False, f\\\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+ if sys.platform != \\\"win32\\\":\\n+ return False, \\\"WaveTone real-backend tests require Windows\\\"\\n+ if not (os.environ.get(\\\"WAVETONE_EXE\\\") or os.environ.get(\\\"WAVETONE_HOME\\\")):\\n+ return False, \\\"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+\\n+ status = wavetone_backend.doctor()\\n+ if status.get(\\\"ready\\\"):\\n+ return True, \\\"\\\"\\n+\\n+ failed_checks = [check[\\\"name\\\"] for check in status.get(\\\"checks\\\", []) if not check.get(\\\"ok\\\")]\\n+ reason = \\\", \\\".join(failed_checks) if failed_checks else \\\"WaveTone backend is not ready\\\"\\n+ return False, f\\\"WaveTone real backend unavailable: {reason}\\\"\\n+\\n+\\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\\n+\\n+\\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_EXE\\\", raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_HOME\\\", raising=False)\\n+\\n+ ready, reason = _real_backend_ready()\\n+\\n+ assert ready is False\\n+ assert REAL_BACKEND_ENV in reason\\n+\\n+\\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setenv(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"1\\\")\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: pytest.fail(\\\"default resolver should not inspect PATH\\\"))\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\") == [sys.executable, \\\"-m\\\", \\\"cli_anything.wavetone.wavetone_cli\\\"]\\n+\\n+\\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: \\\"C:/installed/cli-anything-wavetone.exe\\\")\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\", force_installed=True) == [\\\"C:/installed/cli-anything-wavetone.exe\\\"]\\n+\\n+\\n+class TestCLISubprocess:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_help(self) -> None:\\n+ result = self._run([\\\"--help\\\"])\\n+ assert \\\"Agent-native CLI harness for WaveTone\\\" in result.stdout\\n+\\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\\n+ wav = make_wav(tmp_path / \\\"tone.wav\\\")\\n+ project = tmp_path / \\\"tone.wt.json\\\"\\n+\\n+ result = self._run([\\\"--json\\\", \\\"project\\\", \\\"new\\\", str(wav), \\\"-o\\\", str(project)])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ok\\\"] is True\\n+ assert project.exists()\\n+\\n+ result = self._run(\\n+ [\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"set-tempo\\\", \\\"--bpm\\\", \\\"132.5\\\", \\\"--first-bar\\\", \\\"0.1\\\"]\\n+ )\\n+ assert json.loads(result.stdout)[\\\"tempo\\\"][\\\"bpm\\\"] == 132.5\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"add-label\\\", \\\"intro\\\", \\\"--time\\\", \\\"0.25\\\"])\\n+ assert json.loads(result.stdout)[\\\"labels\\\"][0][\\\"name\\\"] == \\\"intro\\\"\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"audio\\\", \\\"probe\\\"])\\n+ audio = json.loads(result.stdout)[\\\"audio\\\"]\\n+ assert audio[\\\"duration_seconds\\\"] == 0.5\\n+ assert audio[\\\"channels\\\"] == 1\\n+ print(f\\\"\\\\n Project: {project}\\\")\\n+ print(f\\\" Audio: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n+\\n+ def test_formats_json(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"formats\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert \\\".wav\\\" in data[\\\"formats\\\"][\\\"extensions\\\"]\\n+ assert \\\"MP3\\\" in data[\\\"formats\\\"][\\\"from_readme\\\"]\\n+\\n+\\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\\n+class TestRealWaveToneBackend:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_doctor_real_backend(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"doctor\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ready\\\"] is True\\n+ assert any(check[\\\"name\\\"] == \\\"data/asdecoder.exe\\\" and check[\\\"ok\\\"] for check in data[\\\"checks\\\"])\\n+ print(f\\\"\\\\n WaveTone root: {data['root']}\\\")\\n+\\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\\n+ exe = wavetone_backend.find_wavetone()\\n+ wav = make_wav(tmp_path / \\\"launch.wav\\\")\\n+ result = self._run(\\n+ [\\n+ \\\"--json\\\",\\n+ \\\"wavetone\\\",\\n+ \\\"launch\\\",\\n+ str(wav),\\n+ \\\"--exe\\\",\\n+ str(exe),\\n+ \\\"--wait\\\",\\n+ \\\"1\\\",\\n+ \\\"--terminate\\\",\\n+ ]\\n+ )\\n+ data = json.loads(result.stdout)[\\\"launch\\\"]\\n+ assert data[\\\"backend\\\"] == \\\"wavetone.exe\\\"\\n+ assert data[\\\"audio_path\\\"] == str(wav.resolve())\\n+ assert data[\\\"running_after_wait\\\"] is True\\n+ assert data[\\\"terminated\\\"] is True\\n+ print(f\\\"\\\\n Launched WaveTone PID: {data['pid']}\\\")\\n+ print(f\\\" WAV: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Reject non-finite values before writing JSON**\\n\\nWhen any float-valued command path stores `nan` or `inf` in the manifest (for example `project set-tempo --bpm nan` or `project analysis --reference-frequency-hz inf`), this `json.dumps` call uses Python's default `allow_nan=True` and writes `NaN`/`Infinity` tokens into the `.wt.json` file. Those tokens are not valid JSON, so strict consumers of the agent-facing manifest or `--json` output can no longer parse the result; validate finite numeric inputs or serialize with `allow_nan=False` so the command fails instead of corrupting the manifest.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/project.py\",\n \"hunk\": \"@@ -0,0 +1,172 @@\\n+\\\"\\\"\\\"Project manifest helpers for the WaveTone harness.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+from copy import deepcopy\\n+from datetime import datetime, timezone\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+\\n+SCHEMA_VERSION = \\\"wavetone-project/v1\\\"\\n+SOFTWARE_VERSION = \\\"2.61\\\"\\n+SUPPORTED_AUDIO_EXTENSIONS = {\\n+ \\\".wav\\\",\\n+ \\\".wave\\\",\\n+ \\\".aif\\\",\\n+ \\\".aiff\\\",\\n+ \\\".mp3\\\",\\n+ \\\".wma\\\",\\n+ \\\".aac\\\",\\n+ \\\".ogg\\\",\\n+ \\\".oga\\\",\\n+ \\\".flac\\\",\\n+ \\\".wv\\\",\\n+ \\\".ape\\\",\\n+ \\\".alac\\\",\\n+ \\\".tta\\\",\\n+}\\n+\\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\\n+ \\\"blocks_per_second\\\": 12,\\n+ \\\"blocks_per_semitone\\\": 5,\\n+ \\\"note_range\\\": \\\"C1-B7\\\",\\n+ \\\"reference_frequency_hz\\\": 440.0,\\n+ \\\"analyze_fundamental_frequency\\\": True,\\n+ \\\"channel\\\": \\\"Stereo\\\",\\n+ \\\"skip_analysis_dialog\\\": False,\\n+}\\n+\\n+\\n+def now_iso() -> str:\\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\\n+\\n+\\n+def normalize_audio_path(audio_path: str | Path) -> Path:\\n+ path = Path(audio_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Audio file not found: {path}\\\")\\n+ if not path.is_file():\\n+ raise ValueError(f\\\"Audio path is not a file: {path}\\\")\\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\\n+ supported = \\\", \\\".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\\n+ raise ValueError(f\\\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\\\")\\n+ return path\\n+\\n+\\n+def create_project(\\n+ audio_path: str | Path,\\n+ name: str | None = None,\\n+ analysis_settings: dict[str, Any] | None = None,\\n+) -> dict[str, Any]:\\n+ audio = normalize_audio_path(audio_path)\\n+ created_at = now_iso()\\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\\n+ if analysis_settings:\\n+ settings.update(analysis_settings)\\n+\\n+ return {\\n+ \\\"schema_version\\\": SCHEMA_VERSION,\\n+ \\\"software\\\": {\\\"name\\\": \\\"WaveTone\\\", \\\"version\\\": SOFTWARE_VERSION, \\\"backend\\\": \\\"wavetone.exe\\\"},\\n+ \\\"project\\\": {\\\"name\\\": name or audio.stem, \\\"created_at\\\": created_at, \\\"modified_at\\\": created_at},\\n+ \\\"audio\\\": {\\n+ \\\"path\\\": str(audio),\\n+ \\\"filename\\\": audio.name,\\n+ \\\"extension\\\": audio.suffix.lower(),\\n+ \\\"size_bytes\\\": audio.stat().st_size,\\n+ },\\n+ \\\"analysis\\\": settings,\\n+ \\\"tempo\\\": {\\\"bpm\\\": None, \\\"first_bar_time_seconds\\\": 0.0, \\\"meter\\\": \\\"4/4\\\"},\\n+ \\\"labels\\\": [],\\n+ \\\"notes\\\": [],\\n+ \\\"wfd_path\\\": None,\\n+ \\\"limitations\\\": [\\n+ \\\"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\\\",\\n+ \\\"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\\\",\\n+ ],\\n+ }\\n+\\n+\\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\\n+ project.setdefault(\\\"project\\\", {})[\\\"modified_at\\\"] = now_iso()\\n+ return project\\n+\\n+\\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\\n+ path = Path(output_path).expanduser().resolve()\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ touch(project)\\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/project.py b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\\nnew file mode 100644\\nindex 000000000..7e06d8e07\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\\n@@ -0,0 +1,187 @@\\n+\\\"\\\"\\\"Project manifest helpers for the WaveTone harness.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from copy import deepcopy\\n+from datetime import datetime, timezone\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+\\n+SCHEMA_VERSION = \\\"wavetone-project/v1\\\"\\n+SOFTWARE_VERSION = \\\"2.61\\\"\\n+SUPPORTED_AUDIO_EXTENSIONS = {\\n+ \\\".wav\\\",\\n+ \\\".wave\\\",\\n+ \\\".aif\\\",\\n+ \\\".aiff\\\",\\n+ \\\".mp3\\\",\\n+ \\\".wma\\\",\\n+ \\\".aac\\\",\\n+ \\\".ogg\\\",\\n+ \\\".oga\\\",\\n+ \\\".flac\\\",\\n+ \\\".wv\\\",\\n+ \\\".ape\\\",\\n+ \\\".alac\\\",\\n+ \\\".tta\\\",\\n+}\\n+\\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\\n+ \\\"blocks_per_second\\\": 12,\\n+ \\\"blocks_per_semitone\\\": 5,\\n+ \\\"note_range\\\": \\\"C1-B7\\\",\\n+ \\\"reference_frequency_hz\\\": 440.0,\\n+ \\\"analyze_fundamental_frequency\\\": True,\\n+ \\\"channel\\\": \\\"Stereo\\\",\\n+ \\\"skip_analysis_dialog\\\": False,\\n+}\\n+\\n+\\n+def now_iso() -> str:\\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\\n+\\n+\\n+def normalize_audio_path(audio_path: str | Path) -> Path:\\n+ path = Path(audio_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Audio file not found: {path}\\\")\\n+ if not path.is_file():\\n+ raise ValueError(f\\\"Audio path is not a file: {path}\\\")\\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\\n+ supported = \\\", \\\".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\\n+ raise ValueError(f\\\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\\\")\\n+ return path\\n+\\n+\\n+def _finite_float(value: float, field_name: str) -> float:\\n+ number = float(value)\\n+ if not math.isfinite(number):\\n+ raise ValueError(f\\\"{field_name} must be finite\\\")\\n+ return number\\n+\\n+\\n+def create_project(\\n+ audio_path: str | Path,\\n+ name: str | None = None,\\n+ analysis_settings: dict[str, Any] | None = None,\\n+) -> dict[str, Any]:\\n+ audio = normalize_audio_path(audio_path)\\n+ created_at = now_iso()\\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\\n+ if analysis_settings:\\n+ settings.update(analysis_settings)\\n+\\n+ return {\\n+ \\\"schema_version\\\": SCHEMA_VERSION,\\n+ \\\"software\\\": {\\\"name\\\": \\\"WaveTone\\\", \\\"version\\\": SOFTWARE_VERSION, \\\"backend\\\": \\\"wavetone.exe\\\"},\\n+ \\\"project\\\": {\\\"name\\\": name or audio.stem, \\\"created_at\\\": created_at, \\\"modified_at\\\": created_at},\\n+ \\\"audio\\\": {\\n+ \\\"path\\\": str(audio),\\n+ \\\"filename\\\": audio.name,\\n+ \\\"extension\\\": audio.suffix.lower(),\\n+ \\\"size_bytes\\\": audio.stat().st_size,\\n+ },\\n+ \\\"analysis\\\": settings,\\n+ \\\"tempo\\\": {\\\"bpm\\\": None, \\\"first_bar_time_seconds\\\": 0.0, \\\"meter\\\": \\\"4/4\\\"},\\n+ \\\"labels\\\": [],\\n+ \\\"notes\\\": [],\\n+ \\\"wfd_path\\\": None,\\n+ \\\"limitations\\\": [\\n+ \\\"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\\\",\\n+ \\\"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\\\",\\n+ ],\\n+ }\\n+\\n+\\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\\n+ project.setdefault(\\\"project\\\", {})[\\\"modified_at\\\"] = now_iso()\\n+ return project\\n+\\n+\\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\\n+ path = Path(output_path).expanduser().resolve()\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ touch(project)\\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return path\\n+\\n+\\n+def load_project(project_path: str | Path) -> dict[str, Any]:\\n+ path = Path(project_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Project file not found: {path}\\\")\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if not isinstance(data, dict):\\n+ raise ValueError(\\\"Project file must be a JSON object\\\")\\n+ if data.get(\\\"schema_version\\\") != SCHEMA_VERSION:\\n+ raise ValueError(f\\\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\\\")\\n+ return data\\n+\\n+\\n+def add_label(\\n+ project: dict[str, Any],\\n+ name: str,\\n+ time_seconds: float,\\n+ note: str | None = None,\\n+) -> dict[str, Any]:\\n+ time_value = _finite_float(time_seconds, \\\"Label time\\\")\\n+ if time_value < 0:\\n+ raise ValueError(\\\"Label time must be >= 0\\\")\\n+ label: dict[str, Any] = {\\\"name\\\": name, \\\"time_seconds\\\": round(time_value, 6)}\\n+ if note:\\n+ label[\\\"note\\\"] = note\\n+ project.setdefault(\\\"labels\\\", []).append(label)\\n+ project[\\\"labels\\\"].sort(key=lambda item: item[\\\"time_seconds\\\"])\\n+ return touch(project)\\n+\\n+\\n+def set_tempo(\\n+ project: dict[str, Any],\\n+ bpm: float,\\n+ first_bar_time_seconds: float = 0.0,\\n+ meter: str = \\\"4/4\\\",\\n+) -> dict[str, Any]:\\n+ bpm_value = _finite_float(bpm, \\\"BPM\\\")\\n+ first_bar_value = _finite_float(first_bar_time_seconds, \\\"First bar time\\\")\\n+ if bpm_value <= 0:\\n+ raise ValueError(\\\"BPM must be > 0\\\")\\n+ if first_bar_value < 0:\\n+ raise ValueError(\\\"First bar time must be >= 0\\\")\\n+ project[\\\"tempo\\\"] = {\\n+ \\\"bpm\\\": round(bpm_value, 6),\\n+ \\\"first_bar_time_seconds\\\": round(first_bar_value, 6),\\n+ \\\"meter\\\": meter,\\n+ }\\n+ return touch(project)\\n+\\n+\\n+def update_analysis(project: dict[str, Any], **settings: Any) -> dict[str, Any]:\\n+ analysis = project.setdefault(\\\"analysis\\\", deepcopy(DEFAULT_ANALYSIS_SETTINGS))\\n+ for key, value in settings.items():\\n+ if value is not None:\\n+ if isinstance(value, float) and not math.isfinite(value):\\n+ raise ValueError(f\\\"{key} must be finite\\\")\\n+ analysis[key] = value\\n+ return touch(project)\\n+\\n+\\n+def set_wfd_path(project: dict[str, Any], wfd_path: str | Path | None) -> dict[str, Any]:\\n+ project[\\\"wfd_path\\\"] = None if wfd_path is None else str(Path(wfd_path).expanduser().resolve())\\n+ return touch(project)\\n+\\n+\\n+def project_summary(project: dict[str, Any]) -> dict[str, Any]:\\n+ return {\\n+ \\\"schema_version\\\": project.get(\\\"schema_version\\\"),\\n+ \\\"name\\\": project.get(\\\"project\\\", {}).get(\\\"name\\\"),\\n+ \\\"audio\\\": project.get(\\\"audio\\\"),\\n+ \\\"tempo\\\": project.get(\\\"tempo\\\"),\\n+ \\\"label_count\\\": len(project.get(\\\"labels\\\", [])),\\n+ \\\"labels\\\": project.get(\\\"labels\\\", []),\\n+ \\\"analysis\\\": project.get(\\\"analysis\\\"),\\n+ \\\"wfd_path\\\": project.get(\\\"wfd_path\\\"),\\n+ \\\"limitations\\\": project.get(\\\"limitations\\\", []),\\n+ }\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Use a splitter that strips Windows REPL quotes**\\n\\nOn Windows this sets `posix=False`, and `shlex.split()` keeps the surrounding quote characters in each token; for example a REPL command like `project new \\\"C:\\\\Users\\\\me\\\\My Music\\\\song.wav\\\" -o \\\"C:\\\\Users\\\\me\\\\song.wt.json\\\"` passes paths that literally start/end with `\\\"` into Click, so `exists=True` path arguments fail. Because the harness is Windows-targeted and audio/project paths commonly contain spaces, quoted paths entered in the REPL should be unquoted before redispatch.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,358 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"wavetone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = shlex.split(line, posix=(os.name != \\\"nt\\\"))\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"`add_label()` converts `time_seconds` to `time_value` for validation/rounding but then compares the original `time_seconds` against `0`. If callers pass a non-float (e.g., a numeric string), `_finite_float()` will succeed but `time_seconds < 0` will raise `TypeError`. Compare against the validated `time_value` instead to keep behavior consistent with the conversion step.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/project.py\",\n \"hunk\": \"@@ -0,0 +1,185 @@\\n+\\\"\\\"\\\"Project manifest helpers for the WaveTone harness.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from copy import deepcopy\\n+from datetime import datetime, timezone\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+\\n+SCHEMA_VERSION = \\\"wavetone-project/v1\\\"\\n+SOFTWARE_VERSION = \\\"2.61\\\"\\n+SUPPORTED_AUDIO_EXTENSIONS = {\\n+ \\\".wav\\\",\\n+ \\\".wave\\\",\\n+ \\\".aif\\\",\\n+ \\\".aiff\\\",\\n+ \\\".mp3\\\",\\n+ \\\".wma\\\",\\n+ \\\".aac\\\",\\n+ \\\".ogg\\\",\\n+ \\\".oga\\\",\\n+ \\\".flac\\\",\\n+ \\\".wv\\\",\\n+ \\\".ape\\\",\\n+ \\\".alac\\\",\\n+ \\\".tta\\\",\\n+}\\n+\\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\\n+ \\\"blocks_per_second\\\": 12,\\n+ \\\"blocks_per_semitone\\\": 5,\\n+ \\\"note_range\\\": \\\"C1-B7\\\",\\n+ \\\"reference_frequency_hz\\\": 440.0,\\n+ \\\"analyze_fundamental_frequency\\\": True,\\n+ \\\"channel\\\": \\\"Stereo\\\",\\n+ \\\"skip_analysis_dialog\\\": False,\\n+}\\n+\\n+\\n+def now_iso() -> str:\\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\\n+\\n+\\n+def normalize_audio_path(audio_path: str | Path) -> Path:\\n+ path = Path(audio_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Audio file not found: {path}\\\")\\n+ if not path.is_file():\\n+ raise ValueError(f\\\"Audio path is not a file: {path}\\\")\\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\\n+ supported = \\\", \\\".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\\n+ raise ValueError(f\\\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\\\")\\n+ return path\\n+\\n+\\n+def _finite_float(value: float, field_name: str) -> float:\\n+ number = float(value)\\n+ if not math.isfinite(number):\\n+ raise ValueError(f\\\"{field_name} must be finite\\\")\\n+ return number\\n+\\n+\\n+def create_project(\\n+ audio_path: str | Path,\\n+ name: str | None = None,\\n+ analysis_settings: dict[str, Any] | None = None,\\n+) -> dict[str, Any]:\\n+ audio = normalize_audio_path(audio_path)\\n+ created_at = now_iso()\\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\\n+ if analysis_settings:\\n+ settings.update(analysis_settings)\\n+\\n+ return {\\n+ \\\"schema_version\\\": SCHEMA_VERSION,\\n+ \\\"software\\\": {\\\"name\\\": \\\"WaveTone\\\", \\\"version\\\": SOFTWARE_VERSION, \\\"backend\\\": \\\"wavetone.exe\\\"},\\n+ \\\"project\\\": {\\\"name\\\": name or audio.stem, \\\"created_at\\\": created_at, \\\"modified_at\\\": created_at},\\n+ \\\"audio\\\": {\\n+ \\\"path\\\": str(audio),\\n+ \\\"filename\\\": audio.name,\\n+ \\\"extension\\\": audio.suffix.lower(),\\n+ \\\"size_bytes\\\": audio.stat().st_size,\\n+ },\\n+ \\\"analysis\\\": settings,\\n+ \\\"tempo\\\": {\\\"bpm\\\": None, \\\"first_bar_time_seconds\\\": 0.0, \\\"meter\\\": \\\"4/4\\\"},\\n+ \\\"labels\\\": [],\\n+ \\\"notes\\\": [],\\n+ \\\"wfd_path\\\": None,\\n+ \\\"limitations\\\": [\\n+ \\\"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\\\",\\n+ \\\"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\\\",\\n+ ],\\n+ }\\n+\\n+\\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\\n+ project.setdefault(\\\"project\\\", {})[\\\"modified_at\\\"] = now_iso()\\n+ return project\\n+\\n+\\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\\n+ path = Path(output_path).expanduser().resolve()\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ touch(project)\\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return path\\n+\\n+\\n+def load_project(project_path: str | Path) -> dict[str, Any]:\\n+ path = Path(project_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Project file not found: {path}\\\")\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if data.get(\\\"schema_version\\\") != SCHEMA_VERSION:\\n+ raise ValueError(f\\\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\\\")\\n+ return data\\n+\\n+\\n+def add_label(\\n+ project: dict[str, Any],\\n+ name: str,\\n+ time_seconds: float,\\n+ note: str | None = None,\\n+) -> dict[str, Any]:\\n+ time_value = _finite_float(time_seconds, \\\"Label time\\\")\\n+ if time_seconds < 0:\\n+ raise ValueError(\\\"Label time must be >= 0\\\")\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/project.py b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\\nnew file mode 100644\\nindex 000000000..7e06d8e07\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\\n@@ -0,0 +1,187 @@\\n+\\\"\\\"\\\"Project manifest helpers for the WaveTone harness.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from copy import deepcopy\\n+from datetime import datetime, timezone\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+\\n+SCHEMA_VERSION = \\\"wavetone-project/v1\\\"\\n+SOFTWARE_VERSION = \\\"2.61\\\"\\n+SUPPORTED_AUDIO_EXTENSIONS = {\\n+ \\\".wav\\\",\\n+ \\\".wave\\\",\\n+ \\\".aif\\\",\\n+ \\\".aiff\\\",\\n+ \\\".mp3\\\",\\n+ \\\".wma\\\",\\n+ \\\".aac\\\",\\n+ \\\".ogg\\\",\\n+ \\\".oga\\\",\\n+ \\\".flac\\\",\\n+ \\\".wv\\\",\\n+ \\\".ape\\\",\\n+ \\\".alac\\\",\\n+ \\\".tta\\\",\\n+}\\n+\\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\\n+ \\\"blocks_per_second\\\": 12,\\n+ \\\"blocks_per_semitone\\\": 5,\\n+ \\\"note_range\\\": \\\"C1-B7\\\",\\n+ \\\"reference_frequency_hz\\\": 440.0,\\n+ \\\"analyze_fundamental_frequency\\\": True,\\n+ \\\"channel\\\": \\\"Stereo\\\",\\n+ \\\"skip_analysis_dialog\\\": False,\\n+}\\n+\\n+\\n+def now_iso() -> str:\\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\\n+\\n+\\n+def normalize_audio_path(audio_path: str | Path) -> Path:\\n+ path = Path(audio_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Audio file not found: {path}\\\")\\n+ if not path.is_file():\\n+ raise ValueError(f\\\"Audio path is not a file: {path}\\\")\\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\\n+ supported = \\\", \\\".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\\n+ raise ValueError(f\\\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\\\")\\n+ return path\\n+\\n+\\n+def _finite_float(value: float, field_name: str) -> float:\\n+ number = float(value)\\n+ if not math.isfinite(number):\\n+ raise ValueError(f\\\"{field_name} must be finite\\\")\\n+ return number\\n+\\n+\\n+def create_project(\\n+ audio_path: str | Path,\\n+ name: str | None = None,\\n+ analysis_settings: dict[str, Any] | None = None,\\n+) -> dict[str, Any]:\\n+ audio = normalize_audio_path(audio_path)\\n+ created_at = now_iso()\\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\\n+ if analysis_settings:\\n+ settings.update(analysis_settings)\\n+\\n+ return {\\n+ \\\"schema_version\\\": SCHEMA_VERSION,\\n+ \\\"software\\\": {\\\"name\\\": \\\"WaveTone\\\", \\\"version\\\": SOFTWARE_VERSION, \\\"backend\\\": \\\"wavetone.exe\\\"},\\n+ \\\"project\\\": {\\\"name\\\": name or audio.stem, \\\"created_at\\\": created_at, \\\"modified_at\\\": created_at},\\n+ \\\"audio\\\": {\\n+ \\\"path\\\": str(audio),\\n+ \\\"filename\\\": audio.name,\\n+ \\\"extension\\\": audio.suffix.lower(),\\n+ \\\"size_bytes\\\": audio.stat().st_size,\\n+ },\\n+ \\\"analysis\\\": settings,\\n+ \\\"tempo\\\": {\\\"bpm\\\": None, \\\"first_bar_time_seconds\\\": 0.0, \\\"meter\\\": \\\"4/4\\\"},\\n+ \\\"labels\\\": [],\\n+ \\\"notes\\\": [],\\n+ \\\"wfd_path\\\": None,\\n+ \\\"limitations\\\": [\\n+ \\\"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\\\",\\n+ \\\"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\\\",\\n+ ],\\n+ }\\n+\\n+\\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\\n+ project.setdefault(\\\"project\\\", {})[\\\"modified_at\\\"] = now_iso()\\n+ return project\\n+\\n+\\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\\n+ path = Path(output_path).expanduser().resolve()\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ touch(project)\\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return path\\n+\\n+\\n+def load_project(project_path: str | Path) -> dict[str, Any]:\\n+ path = Path(project_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Project file not found: {path}\\\")\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if not isinstance(data, dict):\\n+ raise ValueError(\\\"Project file must be a JSON object\\\")\\n+ if data.get(\\\"schema_version\\\") != SCHEMA_VERSION:\\n+ raise ValueError(f\\\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\\\")\\n+ return data\\n+\\n+\\n+def add_label(\\n+ project: dict[str, Any],\\n+ name: str,\\n+ time_seconds: float,\\n+ note: str | None = None,\\n+) -> dict[str, Any]:\\n+ time_value = _finite_float(time_seconds, \\\"Label time\\\")\\n+ if time_value < 0:\\n+ raise ValueError(\\\"Label time must be >= 0\\\")\\n+ label: dict[str, Any] = {\\\"name\\\": name, \\\"time_seconds\\\": round(time_value, 6)}\\n+ if note:\\n+ label[\\\"note\\\"] = note\\n+ project.setdefault(\\\"labels\\\", []).append(label)\\n+ project[\\\"labels\\\"].sort(key=lambda item: item[\\\"time_seconds\\\"])\\n+ return touch(project)\\n+\\n+\\n+def set_tempo(\\n+ project: dict[str, Any],\\n+ bpm: float,\\n+ first_bar_time_seconds: float = 0.0,\\n+ meter: str = \\\"4/4\\\",\\n+) -> dict[str, Any]:\\n+ bpm_value = _finite_float(bpm, \\\"BPM\\\")\\n+ first_bar_value = _finite_float(first_bar_time_seconds, \\\"First bar time\\\")\\n+ if bpm_value <= 0:\\n+ raise ValueError(\\\"BPM must be > 0\\\")\\n+ if first_bar_value < 0:\\n+ raise ValueError(\\\"First bar time must be >= 0\\\")\\n+ project[\\\"tempo\\\"] = {\\n+ \\\"bpm\\\": round(bpm_value, 6),\\n+ \\\"first_bar_time_seconds\\\": round(first_bar_value, 6),\\n+ \\\"meter\\\": meter,\\n+ }\\n+ return touch(project)\\n+\\n+\\n+def update_analysis(project: dict[str, Any], **settings: Any) -> dict[str, Any]:\\n+ analysis = project.setdefault(\\\"analysis\\\", deepcopy(DEFAULT_ANALYSIS_SETTINGS))\\n+ for key, value in settings.items():\\n+ if value is not None:\\n+ if isinstance(value, float) and not math.isfinite(value):\\n+ raise ValueError(f\\\"{key} must be finite\\\")\\n+ analysis[key] = value\\n+ return touch(project)\\n+\\n+\\n+def set_wfd_path(project: dict[str, Any], wfd_path: str | Path | None) -> dict[str, Any]:\\n+ project[\\\"wfd_path\\\"] = None if wfd_path is None else str(Path(wfd_path).expanduser().resolve())\\n+ return touch(project)\\n+\\n+\\n+def project_summary(project: dict[str, Any]) -> dict[str, Any]:\\n+ return {\\n+ \\\"schema_version\\\": project.get(\\\"schema_version\\\"),\\n+ \\\"name\\\": project.get(\\\"project\\\", {}).get(\\\"name\\\"),\\n+ \\\"audio\\\": project.get(\\\"audio\\\"),\\n+ \\\"tempo\\\": project.get(\\\"tempo\\\"),\\n+ \\\"label_count\\\": len(project.get(\\\"labels\\\", [])),\\n+ \\\"labels\\\": project.get(\\\"labels\\\", []),\\n+ \\\"analysis\\\": project.get(\\\"analysis\\\"),\\n+ \\\"wfd_path\\\": project.get(\\\"wfd_path\\\"),\\n+ \\\"limitations\\\": project.get(\\\"limitations\\\", []),\\n+ }\\n\"\n },\n {\n \"comment\": \"In `_probe_ffprobe()`, `sample_rate`, `bit_rate`, and `size_bytes` are normalized to ints, but `channels` is returned “as-is”. For consistency and to avoid type drift from ffprobe output variations, parse `channels` via the same `_safe_int()` helper.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/audio.py\",\n \"hunk\": \"@@ -0,0 +1,112 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _safe_float(value: Any) -> float | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return float(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _safe_int(value: Any) -> int | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return int(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\\\",\\n+ \\\"-of\\\",\\n+ \\\"json\\\",\\n+ str(path),\\n+ ],\\n+ capture_output=True,\\n+ text=True,\\n+ check=True,\\n+ )\\n+ data = json.loads(result.stdout)\\n+ audio_stream = next(\\n+ (stream for stream in data.get(\\\"streams\\\", []) if stream.get(\\\"codec_type\\\") == \\\"audio\\\"),\\n+ {},\\n+ )\\n+ fmt = data.get(\\\"format\\\", {})\\n+ duration = _safe_float(fmt.get(\\\"duration\\\"))\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": fmt.get(\\\"format_name\\\"),\\n+ \\\"codec\\\": audio_stream.get(\\\"codec_name\\\"),\\n+ \\\"duration_seconds\\\": round(duration, 6) if duration is not None else None,\\n+ \\\"sample_rate\\\": _safe_int(audio_stream.get(\\\"sample_rate\\\")),\\n+ \\\"channels\\\": audio_stream.get(\\\"channels\\\"),\\n+ \\\"bit_rate\\\": _safe_int(fmt.get(\\\"bit_rate\\\")),\\n+ \\\"size_bytes\\\": _safe_int(fmt.get(\\\"size\\\")) or path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"ffprobe\\\",\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/audio.py b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\nnew file mode 100644\\nindex 000000000..f35f343f5\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/audio.py\\n@@ -0,0 +1,112 @@\\n+\\\"\\\"\\\"Audio probing utilities for WaveTone projects.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shutil\\n+import subprocess\\n+import wave\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import normalize_audio_path\\n+\\n+\\n+def _safe_float(value: Any) -> float | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return float(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _safe_int(value: Any) -> int | None:\\n+ if value in (None, \\\"\\\", \\\"N/A\\\"):\\n+ return None\\n+ try:\\n+ return int(value)\\n+ except (TypeError, ValueError):\\n+ return None\\n+\\n+\\n+def _probe_wav_stdlib(path: Path) -> dict[str, Any]:\\n+ with wave.open(str(path), \\\"rb\\\") as handle:\\n+ frames = handle.getnframes()\\n+ sample_rate = handle.getframerate()\\n+ channels = handle.getnchannels()\\n+ sample_width = handle.getsampwidth()\\n+ duration = frames / sample_rate if sample_rate else 0.0\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": \\\"wav\\\",\\n+ \\\"codec\\\": \\\"pcm\\\",\\n+ \\\"duration_seconds\\\": round(duration, 6),\\n+ \\\"sample_rate\\\": sample_rate,\\n+ \\\"channels\\\": channels,\\n+ \\\"sample_width_bytes\\\": sample_width,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"python-wave\\\",\\n+ }\\n+\\n+\\n+def _probe_ffprobe(path: Path) -> dict[str, Any]:\\n+ ffprobe = shutil.which(\\\"ffprobe\\\")\\n+ if not ffprobe:\\n+ raise RuntimeError(\\\"ffprobe not found\\\")\\n+ result = subprocess.run(\\n+ [\\n+ ffprobe,\\n+ \\\"-v\\\",\\n+ \\\"error\\\",\\n+ \\\"-show_entries\\\",\\n+ \\\"stream=codec_type,codec_name,sample_rate,channels:format=duration,format_name,bit_rate,size\\\",\\n+ \\\"-of\\\",\\n+ \\\"json\\\",\\n+ str(path),\\n+ ],\\n+ capture_output=True,\\n+ text=True,\\n+ check=True,\\n+ )\\n+ data = json.loads(result.stdout)\\n+ audio_stream = next(\\n+ (stream for stream in data.get(\\\"streams\\\", []) if stream.get(\\\"codec_type\\\") == \\\"audio\\\"),\\n+ {},\\n+ )\\n+ fmt = data.get(\\\"format\\\", {})\\n+ duration = _safe_float(fmt.get(\\\"duration\\\"))\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": fmt.get(\\\"format_name\\\"),\\n+ \\\"codec\\\": audio_stream.get(\\\"codec_name\\\"),\\n+ \\\"duration_seconds\\\": round(duration, 6) if duration is not None else None,\\n+ \\\"sample_rate\\\": _safe_int(audio_stream.get(\\\"sample_rate\\\")),\\n+ \\\"channels\\\": _safe_int(audio_stream.get(\\\"channels\\\")),\\n+ \\\"bit_rate\\\": _safe_int(fmt.get(\\\"bit_rate\\\")),\\n+ \\\"size_bytes\\\": _safe_int(fmt.get(\\\"size\\\")) or path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"ffprobe\\\",\\n+ }\\n+\\n+\\n+def probe_audio(audio_path: str | Path) -> dict[str, Any]:\\n+ path = normalize_audio_path(audio_path)\\n+ if path.suffix.lower() in {\\\".wav\\\", \\\".wave\\\"}:\\n+ try:\\n+ return _probe_wav_stdlib(path)\\n+ except (wave.Error, EOFError):\\n+ pass\\n+ try:\\n+ return _probe_ffprobe(path)\\n+ except (RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError):\\n+ return {\\n+ \\\"path\\\": str(path),\\n+ \\\"format\\\": path.suffix.lower().lstrip(\\\".\\\") or None,\\n+ \\\"codec\\\": None,\\n+ \\\"duration_seconds\\\": None,\\n+ \\\"sample_rate\\\": None,\\n+ \\\"channels\\\": None,\\n+ \\\"size_bytes\\\": path.stat().st_size,\\n+ \\\"probe_method\\\": \\\"stat\\\",\\n+ \\\"warning\\\": \\\"Install ffprobe for detailed metadata on this format.\\\",\\n+ }\\n\"\n },\n {\n \"comment\": \"`long_description` reads `cli_anything/wavetone/README.md`, but this file may not be included in the built sdist/wheel unless it’s explicitly included (e.g., via `MANIFEST.in` or `package_data`). Consider ensuring the README is packaged, otherwise published metadata may end up with an empty long description even when the source repo has documentation.\",\n \"path\": \"wavetone/agent-harness/setup.py\",\n \"hunk\": \"@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\\nnew file mode 100644\\nindex 000000000..4821f34d0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/setup.py\\n@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\\n+\\n+setup(\\n+ name=\\\"cli-anything-wavetone\\\",\\n+ version=\\\"1.0.0\\\",\\n+ author=\\\"cli-anything contributors\\\",\\n+ description=(\\n+ \\\"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \\\"\\n+ \\\"analysis manifests and launches the real WaveTone Windows executable.\\\"\\n+ ),\\n+ long_description=readme.read_text(encoding=\\\"utf-8\\\") if readme.exists() else \\\"\\\",\\n+ long_description_content_type=\\\"text/markdown\\\",\\n+ url=\\\"https://github.com/HKUDS/CLI-Anything\\\",\\n+ packages=find_namespace_packages(\\n+ include=[\\\"cli_anything.*\\\"],\\n+ exclude=[\\\"cli_anything.*.tests\\\", \\\"cli_anything.*.tests.*\\\"],\\n+ ),\\n+ classifiers=[\\n+ \\\"Development Status :: 4 - Beta\\\",\\n+ \\\"Intended Audience :: Developers\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Analysis\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Editors\\\",\\n+ \\\"License :: OSI Approved :: MIT License\\\",\\n+ \\\"Programming Language :: Python :: 3\\\",\\n+ \\\"Programming Language :: Python :: 3.10\\\",\\n+ \\\"Programming Language :: Python :: 3.11\\\",\\n+ \\\"Programming Language :: Python :: 3.12\\\",\\n+ \\\"Operating System :: Microsoft :: Windows\\\",\\n+ ],\\n+ python_requires=\\\">=3.10\\\",\\n+ install_requires=[\\\"click>=8.0.0\\\", \\\"prompt-toolkit>=3.0.0\\\"],\\n+ extras_require={\\\"dev\\\": [\\\"pytest>=7.0.0\\\"]},\\n+ entry_points={\\n+ \\\"console_scripts\\\": [\\n+ \\\"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\\\",\\n+ ],\\n+ },\\n+ package_data={\\\"cli_anything.wavetone\\\": [\\\"README.md\\\", \\\"skills/SKILL.md\\\", \\\"skills/*.md\\\"]},\\n+ include_package_data=True,\\n+ zip_safe=False,\\n+)\\n\"\n },\n {\n \"comment\": \"`long_description` reads `cli_anything/wavetone/README.md`, but this file may not be included in the built sdist/wheel unless it’s explicitly included (e.g., via `MANIFEST.in` or `package_data`). Consider ensuring the README is packaged, otherwise published metadata may end up with an empty long description even when the source repo has documentation.\",\n \"path\": \"wavetone/agent-harness/setup.py\",\n \"hunk\": \"@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\\n+\\n+setup(\\n+ name=\\\"cli-anything-wavetone\\\",\\n+ version=\\\"1.0.0\\\",\\n+ author=\\\"cli-anything contributors\\\",\\n+ description=(\\n+ \\\"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \\\"\\n+ \\\"analysis manifests and launches the real WaveTone Windows executable.\\\"\\n+ ),\\n+ long_description=readme.read_text(encoding=\\\"utf-8\\\") if readme.exists() else \\\"\\\",\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/setup.py b/wavetone/agent-harness/setup.py\\nnew file mode 100644\\nindex 000000000..4821f34d0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/setup.py\\n@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Setup for cli-anything-wavetone.\\\"\\\"\\\"\\n+\\n+from pathlib import Path\\n+\\n+from setuptools import find_namespace_packages, setup\\n+\\n+\\n+readme = Path(__file__).parent / \\\"cli_anything\\\" / \\\"wavetone\\\" / \\\"README.md\\\"\\n+\\n+setup(\\n+ name=\\\"cli-anything-wavetone\\\",\\n+ version=\\\"1.0.0\\\",\\n+ author=\\\"cli-anything contributors\\\",\\n+ description=(\\n+ \\\"Agent-native CLI harness for WaveTone 2.61. Creates structured audio \\\"\\n+ \\\"analysis manifests and launches the real WaveTone Windows executable.\\\"\\n+ ),\\n+ long_description=readme.read_text(encoding=\\\"utf-8\\\") if readme.exists() else \\\"\\\",\\n+ long_description_content_type=\\\"text/markdown\\\",\\n+ url=\\\"https://github.com/HKUDS/CLI-Anything\\\",\\n+ packages=find_namespace_packages(\\n+ include=[\\\"cli_anything.*\\\"],\\n+ exclude=[\\\"cli_anything.*.tests\\\", \\\"cli_anything.*.tests.*\\\"],\\n+ ),\\n+ classifiers=[\\n+ \\\"Development Status :: 4 - Beta\\\",\\n+ \\\"Intended Audience :: Developers\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Analysis\\\",\\n+ \\\"Topic :: Multimedia :: Sound/Audio :: Editors\\\",\\n+ \\\"License :: OSI Approved :: MIT License\\\",\\n+ \\\"Programming Language :: Python :: 3\\\",\\n+ \\\"Programming Language :: Python :: 3.10\\\",\\n+ \\\"Programming Language :: Python :: 3.11\\\",\\n+ \\\"Programming Language :: Python :: 3.12\\\",\\n+ \\\"Operating System :: Microsoft :: Windows\\\",\\n+ ],\\n+ python_requires=\\\">=3.10\\\",\\n+ install_requires=[\\\"click>=8.0.0\\\", \\\"prompt-toolkit>=3.0.0\\\"],\\n+ extras_require={\\\"dev\\\": [\\\"pytest>=7.0.0\\\"]},\\n+ entry_points={\\n+ \\\"console_scripts\\\": [\\n+ \\\"cli-anything-wavetone=cli_anything.wavetone.wavetone_cli:main\\\",\\n+ ],\\n+ },\\n+ package_data={\\\"cli_anything.wavetone\\\": [\\\"README.md\\\", \\\"skills/SKILL.md\\\", \\\"skills/*.md\\\"]},\\n+ include_package_data=True,\\n+ zip_safe=False,\\n+)\\n\"\n },\n {\n \"comment\": \"The same SKILL content appears to be duplicated both here and in `wavetone/agent-harness/cli_anything/wavetone/skills/SKILL.md`. Keeping two sources of truth increases the chance they diverge; consider generating one from the other (build step) or referencing a single canonical copy if the repo structure allows it.\",\n \"path\": \"skills/cli-anything-wavetone/SKILL.md\",\n \"hunk\": \"@@ -0,0 +1,53 @@\\n+---\\n+name: \\\"cli-anything-wavetone\\\"\\n+description: \\\"Control WaveTone 2.61 workflows through a JSON manifest and launch the real Windows WaveTone executable.\\\"\\n+---\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/skills/cli-anything-wavetone/SKILL.md b/skills/cli-anything-wavetone/SKILL.md\\nnew file mode 100644\\nindex 000000000..a565109ed\\n--- /dev/null\\n+++ b/skills/cli-anything-wavetone/SKILL.md\\n@@ -0,0 +1,53 @@\\n+---\\n+name: \\\"cli-anything-wavetone\\\"\\n+description: \\\"Control WaveTone 2.61 workflows through a JSON manifest and launch the real Windows WaveTone executable.\\\"\\n+---\\n+\\n+# cli-anything-wavetone\\n+\\n+Use this skill when an agent needs to prepare, inspect, and launch WaveTone 2.61\\n+audio transcription workflows.\\n+\\n+## Requirements\\n+\\n+- Windows host.\\n+- WaveTone 2.61 extracted locally.\\n+- Set `WAVETONE_EXE` to `wavetone.exe` or `WAVETONE_HOME` to the extracted\\n+ WaveTone directory when the default portable path is not used.\\n+\\n+## Core Commands\\n+\\n+All commands support the top-level `--json` flag.\\n+\\n+```bash\\n+cli-anything-wavetone --json wavetone doctor\\n+cli-anything-wavetone --json project new input.wav -o project.wt.json\\n+cli-anything-wavetone --project project.wt.json --json audio probe\\n+cli-anything-wavetone --project project.wt.json --json project set-tempo --bpm 120 --meter 4/4\\n+cli-anything-wavetone --project project.wt.json --json project add-label chorus --time 64.0\\n+cli-anything-wavetone --project project.wt.json --json wavetone launch\\n+```\\n+\\n+## Command Groups\\n+\\n+- `project`: create manifests, set tempo, add labels, update intended analysis\\n+ settings, and attach a WFD saved from WaveTone.\\n+- `audio`: probe audio metadata before opening it in WaveTone.\\n+- `wavetone`: run `doctor`, list supported formats, or launch the real GUI.\\n+- `session`: record lightweight event logs for multi-step agent workflows.\\n+- `defaults`: show default analysis settings.\\n+\\n+## Agent Guidance\\n+\\n+The JSON project manifest is not a WaveTone WFD file. It is an agent-facing plan\\n+for the source audio, intended analysis settings, labels, and tempo metadata.\\n+Use WaveTone itself to perform analysis and save WFD/MIDI/text/WAVE outputs.\\n+\\n+When running in automated checks, use:\\n+\\n+```bash\\n+cli-anything-wavetone --json wavetone launch input.wav --wait 1 --terminate\\n+```\\n+\\n+This confirms that the real backend can be started without leaving a persistent\\n+GUI process behind.\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Reject non-object project JSON**\\n\\nWhen the project path points to a syntactically valid JSON file whose top-level value is not an object, such as `[]`, `json.loads` succeeds but this `.get` call raises `AttributeError`. The CLI handlers only convert `OSError`/`ValueError` into Click errors, so `project info` and project mutation commands exit with a traceback instead of a clean error/JSON failure; validate `isinstance(data, dict)` and raise `ValueError` before using `.get`.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/project.py\",\n \"hunk\": \"@@ -0,0 +1,185 @@\\n+\\\"\\\"\\\"Project manifest helpers for the WaveTone harness.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from copy import deepcopy\\n+from datetime import datetime, timezone\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+\\n+SCHEMA_VERSION = \\\"wavetone-project/v1\\\"\\n+SOFTWARE_VERSION = \\\"2.61\\\"\\n+SUPPORTED_AUDIO_EXTENSIONS = {\\n+ \\\".wav\\\",\\n+ \\\".wave\\\",\\n+ \\\".aif\\\",\\n+ \\\".aiff\\\",\\n+ \\\".mp3\\\",\\n+ \\\".wma\\\",\\n+ \\\".aac\\\",\\n+ \\\".ogg\\\",\\n+ \\\".oga\\\",\\n+ \\\".flac\\\",\\n+ \\\".wv\\\",\\n+ \\\".ape\\\",\\n+ \\\".alac\\\",\\n+ \\\".tta\\\",\\n+}\\n+\\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\\n+ \\\"blocks_per_second\\\": 12,\\n+ \\\"blocks_per_semitone\\\": 5,\\n+ \\\"note_range\\\": \\\"C1-B7\\\",\\n+ \\\"reference_frequency_hz\\\": 440.0,\\n+ \\\"analyze_fundamental_frequency\\\": True,\\n+ \\\"channel\\\": \\\"Stereo\\\",\\n+ \\\"skip_analysis_dialog\\\": False,\\n+}\\n+\\n+\\n+def now_iso() -> str:\\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\\n+\\n+\\n+def normalize_audio_path(audio_path: str | Path) -> Path:\\n+ path = Path(audio_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Audio file not found: {path}\\\")\\n+ if not path.is_file():\\n+ raise ValueError(f\\\"Audio path is not a file: {path}\\\")\\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\\n+ supported = \\\", \\\".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\\n+ raise ValueError(f\\\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\\\")\\n+ return path\\n+\\n+\\n+def _finite_float(value: float, field_name: str) -> float:\\n+ number = float(value)\\n+ if not math.isfinite(number):\\n+ raise ValueError(f\\\"{field_name} must be finite\\\")\\n+ return number\\n+\\n+\\n+def create_project(\\n+ audio_path: str | Path,\\n+ name: str | None = None,\\n+ analysis_settings: dict[str, Any] | None = None,\\n+) -> dict[str, Any]:\\n+ audio = normalize_audio_path(audio_path)\\n+ created_at = now_iso()\\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\\n+ if analysis_settings:\\n+ settings.update(analysis_settings)\\n+\\n+ return {\\n+ \\\"schema_version\\\": SCHEMA_VERSION,\\n+ \\\"software\\\": {\\\"name\\\": \\\"WaveTone\\\", \\\"version\\\": SOFTWARE_VERSION, \\\"backend\\\": \\\"wavetone.exe\\\"},\\n+ \\\"project\\\": {\\\"name\\\": name or audio.stem, \\\"created_at\\\": created_at, \\\"modified_at\\\": created_at},\\n+ \\\"audio\\\": {\\n+ \\\"path\\\": str(audio),\\n+ \\\"filename\\\": audio.name,\\n+ \\\"extension\\\": audio.suffix.lower(),\\n+ \\\"size_bytes\\\": audio.stat().st_size,\\n+ },\\n+ \\\"analysis\\\": settings,\\n+ \\\"tempo\\\": {\\\"bpm\\\": None, \\\"first_bar_time_seconds\\\": 0.0, \\\"meter\\\": \\\"4/4\\\"},\\n+ \\\"labels\\\": [],\\n+ \\\"notes\\\": [],\\n+ \\\"wfd_path\\\": None,\\n+ \\\"limitations\\\": [\\n+ \\\"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\\\",\\n+ \\\"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\\\",\\n+ ],\\n+ }\\n+\\n+\\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\\n+ project.setdefault(\\\"project\\\", {})[\\\"modified_at\\\"] = now_iso()\\n+ return project\\n+\\n+\\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\\n+ path = Path(output_path).expanduser().resolve()\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ touch(project)\\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return path\\n+\\n+\\n+def load_project(project_path: str | Path) -> dict[str, Any]:\\n+ path = Path(project_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Project file not found: {path}\\\")\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if data.get(\\\"schema_version\\\") != SCHEMA_VERSION:\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/project.py b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\\nnew file mode 100644\\nindex 000000000..7e06d8e07\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/project.py\\n@@ -0,0 +1,187 @@\\n+\\\"\\\"\\\"Project manifest helpers for the WaveTone harness.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from copy import deepcopy\\n+from datetime import datetime, timezone\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+\\n+SCHEMA_VERSION = \\\"wavetone-project/v1\\\"\\n+SOFTWARE_VERSION = \\\"2.61\\\"\\n+SUPPORTED_AUDIO_EXTENSIONS = {\\n+ \\\".wav\\\",\\n+ \\\".wave\\\",\\n+ \\\".aif\\\",\\n+ \\\".aiff\\\",\\n+ \\\".mp3\\\",\\n+ \\\".wma\\\",\\n+ \\\".aac\\\",\\n+ \\\".ogg\\\",\\n+ \\\".oga\\\",\\n+ \\\".flac\\\",\\n+ \\\".wv\\\",\\n+ \\\".ape\\\",\\n+ \\\".alac\\\",\\n+ \\\".tta\\\",\\n+}\\n+\\n+DEFAULT_ANALYSIS_SETTINGS: dict[str, Any] = {\\n+ \\\"blocks_per_second\\\": 12,\\n+ \\\"blocks_per_semitone\\\": 5,\\n+ \\\"note_range\\\": \\\"C1-B7\\\",\\n+ \\\"reference_frequency_hz\\\": 440.0,\\n+ \\\"analyze_fundamental_frequency\\\": True,\\n+ \\\"channel\\\": \\\"Stereo\\\",\\n+ \\\"skip_analysis_dialog\\\": False,\\n+}\\n+\\n+\\n+def now_iso() -> str:\\n+ return datetime.now(timezone.utc).replace(microsecond=0).isoformat()\\n+\\n+\\n+def normalize_audio_path(audio_path: str | Path) -> Path:\\n+ path = Path(audio_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Audio file not found: {path}\\\")\\n+ if not path.is_file():\\n+ raise ValueError(f\\\"Audio path is not a file: {path}\\\")\\n+ if path.suffix.lower() not in SUPPORTED_AUDIO_EXTENSIONS:\\n+ supported = \\\", \\\".join(sorted(SUPPORTED_AUDIO_EXTENSIONS))\\n+ raise ValueError(f\\\"Unsupported audio extension {path.suffix!r}. Supported: {supported}\\\")\\n+ return path\\n+\\n+\\n+def _finite_float(value: float, field_name: str) -> float:\\n+ number = float(value)\\n+ if not math.isfinite(number):\\n+ raise ValueError(f\\\"{field_name} must be finite\\\")\\n+ return number\\n+\\n+\\n+def create_project(\\n+ audio_path: str | Path,\\n+ name: str | None = None,\\n+ analysis_settings: dict[str, Any] | None = None,\\n+) -> dict[str, Any]:\\n+ audio = normalize_audio_path(audio_path)\\n+ created_at = now_iso()\\n+ settings = deepcopy(DEFAULT_ANALYSIS_SETTINGS)\\n+ if analysis_settings:\\n+ settings.update(analysis_settings)\\n+\\n+ return {\\n+ \\\"schema_version\\\": SCHEMA_VERSION,\\n+ \\\"software\\\": {\\\"name\\\": \\\"WaveTone\\\", \\\"version\\\": SOFTWARE_VERSION, \\\"backend\\\": \\\"wavetone.exe\\\"},\\n+ \\\"project\\\": {\\\"name\\\": name or audio.stem, \\\"created_at\\\": created_at, \\\"modified_at\\\": created_at},\\n+ \\\"audio\\\": {\\n+ \\\"path\\\": str(audio),\\n+ \\\"filename\\\": audio.name,\\n+ \\\"extension\\\": audio.suffix.lower(),\\n+ \\\"size_bytes\\\": audio.stat().st_size,\\n+ },\\n+ \\\"analysis\\\": settings,\\n+ \\\"tempo\\\": {\\\"bpm\\\": None, \\\"first_bar_time_seconds\\\": 0.0, \\\"meter\\\": \\\"4/4\\\"},\\n+ \\\"labels\\\": [],\\n+ \\\"notes\\\": [],\\n+ \\\"wfd_path\\\": None,\\n+ \\\"limitations\\\": [\\n+ \\\"WaveTone 2.61 exposes analysis, MIDI/text export, and WAVE export through GUI menus.\\\",\\n+ \\\"This manifest is an agent-facing plan; WFD analysis data must be saved by WaveTone itself.\\\",\\n+ ],\\n+ }\\n+\\n+\\n+def touch(project: dict[str, Any]) -> dict[str, Any]:\\n+ project.setdefault(\\\"project\\\", {})[\\\"modified_at\\\"] = now_iso()\\n+ return project\\n+\\n+\\n+def save_project(project: dict[str, Any], output_path: str | Path) -> Path:\\n+ path = Path(output_path).expanduser().resolve()\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ touch(project)\\n+ path.write_text(json.dumps(project, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return path\\n+\\n+\\n+def load_project(project_path: str | Path) -> dict[str, Any]:\\n+ path = Path(project_path).expanduser().resolve()\\n+ if not path.exists():\\n+ raise FileNotFoundError(f\\\"Project file not found: {path}\\\")\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if not isinstance(data, dict):\\n+ raise ValueError(\\\"Project file must be a JSON object\\\")\\n+ if data.get(\\\"schema_version\\\") != SCHEMA_VERSION:\\n+ raise ValueError(f\\\"Unsupported WaveTone project schema: {data.get('schema_version')!r}\\\")\\n+ return data\\n+\\n+\\n+def add_label(\\n+ project: dict[str, Any],\\n+ name: str,\\n+ time_seconds: float,\\n+ note: str | None = None,\\n+) -> dict[str, Any]:\\n+ time_value = _finite_float(time_seconds, \\\"Label time\\\")\\n+ if time_value < 0:\\n+ raise ValueError(\\\"Label time must be >= 0\\\")\\n+ label: dict[str, Any] = {\\\"name\\\": name, \\\"time_seconds\\\": round(time_value, 6)}\\n+ if note:\\n+ label[\\\"note\\\"] = note\\n+ project.setdefault(\\\"labels\\\", []).append(label)\\n+ project[\\\"labels\\\"].sort(key=lambda item: item[\\\"time_seconds\\\"])\\n+ return touch(project)\\n+\\n+\\n+def set_tempo(\\n+ project: dict[str, Any],\\n+ bpm: float,\\n+ first_bar_time_seconds: float = 0.0,\\n+ meter: str = \\\"4/4\\\",\\n+) -> dict[str, Any]:\\n+ bpm_value = _finite_float(bpm, \\\"BPM\\\")\\n+ first_bar_value = _finite_float(first_bar_time_seconds, \\\"First bar time\\\")\\n+ if bpm_value <= 0:\\n+ raise ValueError(\\\"BPM must be > 0\\\")\\n+ if first_bar_value < 0:\\n+ raise ValueError(\\\"First bar time must be >= 0\\\")\\n+ project[\\\"tempo\\\"] = {\\n+ \\\"bpm\\\": round(bpm_value, 6),\\n+ \\\"first_bar_time_seconds\\\": round(first_bar_value, 6),\\n+ \\\"meter\\\": meter,\\n+ }\\n+ return touch(project)\\n+\\n+\\n+def update_analysis(project: dict[str, Any], **settings: Any) -> dict[str, Any]:\\n+ analysis = project.setdefault(\\\"analysis\\\", deepcopy(DEFAULT_ANALYSIS_SETTINGS))\\n+ for key, value in settings.items():\\n+ if value is not None:\\n+ if isinstance(value, float) and not math.isfinite(value):\\n+ raise ValueError(f\\\"{key} must be finite\\\")\\n+ analysis[key] = value\\n+ return touch(project)\\n+\\n+\\n+def set_wfd_path(project: dict[str, Any], wfd_path: str | Path | None) -> dict[str, Any]:\\n+ project[\\\"wfd_path\\\"] = None if wfd_path is None else str(Path(wfd_path).expanduser().resolve())\\n+ return touch(project)\\n+\\n+\\n+def project_summary(project: dict[str, Any]) -> dict[str, Any]:\\n+ return {\\n+ \\\"schema_version\\\": project.get(\\\"schema_version\\\"),\\n+ \\\"name\\\": project.get(\\\"project\\\", {}).get(\\\"name\\\"),\\n+ \\\"audio\\\": project.get(\\\"audio\\\"),\\n+ \\\"tempo\\\": project.get(\\\"tempo\\\"),\\n+ \\\"label_count\\\": len(project.get(\\\"labels\\\", [])),\\n+ \\\"labels\\\": project.get(\\\"labels\\\", []),\\n+ \\\"analysis\\\": project.get(\\\"analysis\\\"),\\n+ \\\"wfd_path\\\": project.get(\\\"wfd_path\\\"),\\n+ \\\"limitations\\\": project.get(\\\"limitations\\\", []),\\n+ }\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Reject non-finite session payload values**\\n\\nWhen `session record --payload` contains `NaN` or `Infinity`, Python's JSON parser accepts those constants and this write uses the default `allow_nan=True`, so the session log (and the `--json` response) contains non-standard JSON tokens that strict consumers cannot parse. Reject these constants during payload parsing or serialize with `allow_nan=False` so the command fails before corrupting the session file.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/core/session.py\",\n \"hunk\": \"@@ -0,0 +1,48 @@\\n+\\\"\\\"\\\"Small session event log for WaveTone CLI runs.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import now_iso\\n+\\n+\\n+def _new_session() -> dict[str, Any]:\\n+ return {\\\"schema_version\\\": \\\"wavetone-session/v1\\\", \\\"events\\\": []}\\n+\\n+\\n+def _load_session_data(path: Path) -> dict[str, Any]:\\n+ if not path.exists():\\n+ return _new_session()\\n+\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if not isinstance(data, dict):\\n+ raise ValueError(\\\"Session file must be a JSON object\\\")\\n+\\n+ events = data.get(\\\"events\\\")\\n+ if events is None:\\n+ data[\\\"events\\\"] = []\\n+ elif not isinstance(events, list):\\n+ raise ValueError(\\\"Session file field 'events' must be a list\\\")\\n+\\n+ return data\\n+\\n+\\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ data = _load_session_data(path)\\n+ record = {\\\"time\\\": now_iso(), \\\"event\\\": event, \\\"payload\\\": payload}\\n+ data[\\\"events\\\"].append(record)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/core/session.py b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\\nnew file mode 100644\\nindex 000000000..d9f2c7f26\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/core/session.py\\n@@ -0,0 +1,61 @@\\n+\\\"\\\"\\\"Small session event log for WaveTone CLI runs.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import math\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from .project import now_iso\\n+\\n+\\n+def _new_session() -> dict[str, Any]:\\n+ return {\\\"schema_version\\\": \\\"wavetone-session/v1\\\", \\\"events\\\": []}\\n+\\n+\\n+def _assert_json_safe(value: Any, path: str = \\\"payload\\\") -> None:\\n+ if isinstance(value, float) and not math.isfinite(value):\\n+ raise ValueError(f\\\"{path} must contain only finite numbers\\\")\\n+ if isinstance(value, dict):\\n+ for key, item in value.items():\\n+ _assert_json_safe(item, f\\\"{path}.{key}\\\")\\n+ elif isinstance(value, list):\\n+ for idx, item in enumerate(value):\\n+ _assert_json_safe(item, f\\\"{path}[{idx}]\\\")\\n+\\n+\\n+def _load_session_data(path: Path) -> dict[str, Any]:\\n+ if not path.exists():\\n+ return _new_session()\\n+\\n+ data = json.loads(path.read_text(encoding=\\\"utf-8\\\"))\\n+ if not isinstance(data, dict):\\n+ raise ValueError(\\\"Session file must be a JSON object\\\")\\n+\\n+ events = data.get(\\\"events\\\")\\n+ if events is None:\\n+ data[\\\"events\\\"] = []\\n+ elif not isinstance(events, list):\\n+ raise ValueError(\\\"Session file field 'events' must be a list\\\")\\n+\\n+ return data\\n+\\n+\\n+def append_event(session_path: str | Path, event: str, payload: dict[str, Any]) -> dict[str, Any]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ data = _load_session_data(path)\\n+ _assert_json_safe(payload)\\n+ record = {\\\"time\\\": now_iso(), \\\"event\\\": event, \\\"payload\\\": payload}\\n+ data[\\\"events\\\"].append(record)\\n+ path.parent.mkdir(parents=True, exist_ok=True)\\n+ path.write_text(json.dumps(data, indent=2, sort_keys=True, allow_nan=False) + \\\"\\\\n\\\", encoding=\\\"utf-8\\\")\\n+ return record\\n+\\n+\\n+def load_events(session_path: str | Path) -> list[dict[str, Any]]:\\n+ path = Path(session_path).expanduser().resolve()\\n+ if not path.exists():\\n+ return []\\n+ data = _load_session_data(path)\\n+ return list(data[\\\"events\\\"])\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Convert non-Windows launch failures to Click errors**\\n\\nWhen `cli-anything-wavetone --json wavetone launch` is run on a non-Windows host, `wavetone_backend.launch_wavetone()` raises `RuntimeError(\\\"WaveTone launch requires Windows\\\")`, but this handler only converts `OSError` and `ValueError` into `ClickException`. The result is an uncaught traceback instead of the CLI's normal clean error path/JSON-safe behavior, which affects Linux/macOS environments that can still run the CLI-only commands and skipped backend tests.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,367 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"wavetone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental/--no-fundamental\\\", default=None)\\n+@click.option(\\\"--skip-dialog/--show-dialog\\\", default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, ValueError) as exc:\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"`--fundamental/--no-fundamental` and `--skip-dialog/--show-dialog` are intended to be tri-state (so omitted flags don’t overwrite existing manifest settings), but Click boolean flag pairs typically coerce a `None` default into `False` for flags. This causes `project analysis` to always write `False` for these settings even when the user doesn’t pass either flag. Use two options with the same destination and `flag_value` (defaulting to `None`) to preserve tri-state behavior (e.g., `--fundamental` sets True, `--no-fundamental` sets False, else None), and the same pattern for `skip_dialog`.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,367 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"wavetone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental/--no-fundamental\\\", default=None)\\n+@click.option(\\\"--skip-dialog/--show-dialog\\\", default=None)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"`doctor()` marks required decoder artifacts as OK if a path merely exists; this will incorrectly pass when a required file path is a directory. Use `path.is_file()` (and optionally guard the loop when `data_dir` is not a directory) so `ready` reflects a valid WaveTone installation.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\",\n \"hunk\": \"@@ -0,0 +1,163 @@\\n+\\\"\\\"\\\"Backend wrapper for the real WaveTone 2.61 executable.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import os\\n+import platform\\n+import subprocess\\n+import time\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\\n+\\n+\\n+REQUIRED_DATA_FILES = [\\n+ \\\"awlib.dll\\\",\\n+ \\\"bass.dll\\\",\\n+ \\\"bassflac.dll\\\",\\n+ \\\"basswma.dll\\\",\\n+ \\\"basswv.dll\\\",\\n+ \\\"bass_aac.dll\\\",\\n+ \\\"bass_alac.dll\\\",\\n+ \\\"bass_ape.dll\\\",\\n+ \\\"bass_tta.dll\\\",\\n+ \\\"asdecoder.exe\\\",\\n+]\\n+\\n+\\n+def default_candidates() -> list[Path]:\\n+ candidates: list[Path] = []\\n+ env_exe = os.environ.get(\\\"WAVETONE_EXE\\\")\\n+ if env_exe:\\n+ candidates.append(Path(env_exe))\\n+ env_home = os.environ.get(\\\"WAVETONE_HOME\\\")\\n+ if env_home:\\n+ candidates.append(Path(env_home) / \\\"wavetone.exe\\\")\\n+ candidates.append(Path(env_home) / \\\"WaveTone.exe\\\")\\n+ home = Path.home()\\n+ candidates.extend(\\n+ [\\n+ home / \\\"Desktop\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ home / \\\"Downloads\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ Path(\\\"C:/Program Files/WaveTone/wavetone.exe\\\"),\\n+ Path(\\\"C:/Program Files (x86)/WaveTone/wavetone.exe\\\"),\\n+ ]\\n+ )\\n+ return candidates\\n+\\n+\\n+def find_wavetone(executable: str | Path | None = None) -> Path:\\n+ candidates = [Path(executable)] if executable else default_candidates()\\n+ checked: list[str] = []\\n+ for candidate in candidates:\\n+ path = candidate.expanduser()\\n+ checked.append(str(path))\\n+ if path.exists() and path.is_file():\\n+ return path.resolve()\\n+ raise FileNotFoundError(\\n+ \\\"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \\\"\\n+ \\\"WAVETONE_HOME to the extracted WaveTone directory. Checked: \\\"\\n+ + \\\"; \\\".join(checked)\\n+ )\\n+\\n+\\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\\n+ checks: list[dict[str, Any]] = []\\n+ try:\\n+ exe = find_wavetone(executable)\\n+ root = exe.parent\\n+ checks.append({\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": True, \\\"path\\\": str(exe)})\\n+ except FileNotFoundError as exc:\\n+ return {\\n+ \\\"ready\\\": False,\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"checks\\\": [{\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": False, \\\"error\\\": str(exc)}],\\n+ }\\n+\\n+ data_dir = root / \\\"data\\\"\\n+ checks.append({\\\"name\\\": \\\"data directory\\\", \\\"ok\\\": data_dir.is_dir(), \\\"path\\\": str(data_dir)})\\n+ for filename in REQUIRED_DATA_FILES:\\n+ path = data_dir / filename\\n+ checks.append({\\\"name\\\": f\\\"data/{filename}\\\", \\\"ok\\\": path.exists(), \\\"path\\\": str(path)})\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\\nnew file mode 100644\\nindex 000000000..81d3d35ec\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/wavetone_backend.py\\n@@ -0,0 +1,163 @@\\n+\\\"\\\"\\\"Backend wrapper for the real WaveTone 2.61 executable.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import os\\n+import platform\\n+import subprocess\\n+import time\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+from cli_anything.wavetone.core.project import SUPPORTED_AUDIO_EXTENSIONS, normalize_audio_path\\n+\\n+\\n+REQUIRED_DATA_FILES = [\\n+ \\\"awlib.dll\\\",\\n+ \\\"bass.dll\\\",\\n+ \\\"bassflac.dll\\\",\\n+ \\\"basswma.dll\\\",\\n+ \\\"basswv.dll\\\",\\n+ \\\"bass_aac.dll\\\",\\n+ \\\"bass_alac.dll\\\",\\n+ \\\"bass_ape.dll\\\",\\n+ \\\"bass_tta.dll\\\",\\n+ \\\"asdecoder.exe\\\",\\n+]\\n+\\n+\\n+def default_candidates() -> list[Path]:\\n+ candidates: list[Path] = []\\n+ env_exe = os.environ.get(\\\"WAVETONE_EXE\\\")\\n+ if env_exe:\\n+ candidates.append(Path(env_exe))\\n+ env_home = os.environ.get(\\\"WAVETONE_HOME\\\")\\n+ if env_home:\\n+ candidates.append(Path(env_home) / \\\"wavetone.exe\\\")\\n+ candidates.append(Path(env_home) / \\\"WaveTone.exe\\\")\\n+ home = Path.home()\\n+ candidates.extend(\\n+ [\\n+ home / \\\"Desktop\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ home / \\\"Downloads\\\" / \\\"wavetone2.6.1\\\" / \\\"wavetone.exe\\\",\\n+ Path(\\\"C:/Program Files/WaveTone/wavetone.exe\\\"),\\n+ Path(\\\"C:/Program Files (x86)/WaveTone/wavetone.exe\\\"),\\n+ ]\\n+ )\\n+ return candidates\\n+\\n+\\n+def find_wavetone(executable: str | Path | None = None) -> Path:\\n+ candidates = [Path(executable)] if executable else default_candidates()\\n+ checked: list[str] = []\\n+ for candidate in candidates:\\n+ path = candidate.expanduser()\\n+ checked.append(str(path))\\n+ if path.exists() and path.is_file():\\n+ return path.resolve()\\n+ raise FileNotFoundError(\\n+ \\\"WaveTone executable not found. Set WAVETONE_EXE to wavetone.exe or \\\"\\n+ \\\"WAVETONE_HOME to the extracted WaveTone directory. Checked: \\\"\\n+ + \\\"; \\\".join(checked)\\n+ )\\n+\\n+\\n+def doctor(executable: str | Path | None = None) -> dict[str, Any]:\\n+ checks: list[dict[str, Any]] = []\\n+ try:\\n+ exe = find_wavetone(executable)\\n+ root = exe.parent\\n+ checks.append({\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": True, \\\"path\\\": str(exe)})\\n+ except FileNotFoundError as exc:\\n+ return {\\n+ \\\"ready\\\": False,\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"checks\\\": [{\\\"name\\\": \\\"wavetone executable\\\", \\\"ok\\\": False, \\\"error\\\": str(exc)}],\\n+ }\\n+\\n+ data_dir = root / \\\"data\\\"\\n+ checks.append({\\\"name\\\": \\\"data directory\\\", \\\"ok\\\": data_dir.is_dir(), \\\"path\\\": str(data_dir)})\\n+ for filename in REQUIRED_DATA_FILES:\\n+ path = data_dir / filename\\n+ checks.append({\\\"name\\\": f\\\"data/{filename}\\\", \\\"ok\\\": path.is_file(), \\\"path\\\": str(path)})\\n+ help_dir = root / \\\"wthelp\\\"\\n+ checks.append({\\\"name\\\": \\\"help directory\\\", \\\"ok\\\": help_dir.is_dir(), \\\"path\\\": str(help_dir)})\\n+ checks.append(\\n+ {\\n+ \\\"name\\\": \\\"windows host\\\",\\n+ \\\"ok\\\": platform.system().lower() == \\\"windows\\\",\\n+ \\\"platform\\\": platform.platform(),\\n+ }\\n+ )\\n+ return {\\n+ \\\"ready\\\": all(check[\\\"ok\\\"] for check in checks),\\n+ \\\"platform\\\": platform.system(),\\n+ \\\"root\\\": str(root),\\n+ \\\"checks\\\": checks,\\n+ }\\n+\\n+\\n+def launch_wavetone(\\n+ audio_path: str | Path | None = None,\\n+ executable: str | Path | None = None,\\n+ wait_seconds: float = 0.0,\\n+ terminate: bool = False,\\n+) -> dict[str, Any]:\\n+ if platform.system().lower() != \\\"windows\\\":\\n+ raise RuntimeError(\\\"WaveTone launch requires Windows\\\")\\n+\\n+ exe = find_wavetone(executable)\\n+ args = [str(exe)]\\n+ audio: Path | None = None\\n+ if audio_path:\\n+ audio = normalize_audio_path(audio_path)\\n+ args.append(str(audio))\\n+\\n+ process = subprocess.Popen(args, cwd=str(exe.parent))\\n+ if wait_seconds > 0:\\n+ time.sleep(wait_seconds)\\n+ polled = process.poll()\\n+ running_after_wait = polled is None\\n+ exit_code = polled\\n+ terminated = False\\n+ if terminate and running_after_wait:\\n+ process.terminate()\\n+ try:\\n+ process.wait(timeout=3)\\n+ except subprocess.TimeoutExpired:\\n+ process.kill()\\n+ process.wait(timeout=3)\\n+ terminated = True\\n+ exit_code = process.returncode\\n+\\n+ return {\\n+ \\\"backend\\\": \\\"wavetone.exe\\\",\\n+ \\\"executable\\\": str(exe),\\n+ \\\"cwd\\\": str(exe.parent),\\n+ \\\"pid\\\": process.pid,\\n+ \\\"args\\\": args,\\n+ \\\"audio_path\\\": str(audio) if audio else None,\\n+ \\\"running_after_wait\\\": running_after_wait,\\n+ \\\"terminated\\\": terminated,\\n+ \\\"exit_code\\\": exit_code,\\n+ \\\"note\\\": \\\"WaveTone analysis and export dialogs are GUI driven in version 2.61.\\\",\\n+ }\\n+\\n+\\n+def supported_formats() -> dict[str, Any]:\\n+ return {\\n+ \\\"extensions\\\": sorted(SUPPORTED_AUDIO_EXTENSIONS),\\n+ \\\"from_readme\\\": [\\n+ \\\"WAVE\\\",\\n+ \\\"AIFF\\\",\\n+ \\\"MP3\\\",\\n+ \\\"WMA\\\",\\n+ \\\"AAC\\\",\\n+ \\\"Vorbis\\\",\\n+ \\\"FLAC\\\",\\n+ \\\"WavPack\\\",\\n+ \\\"Monkey's Audio\\\",\\n+ \\\"ALAC\\\",\\n+ \\\"TTA\\\",\\n+ ],\\n+ }\\n\"\n },\n {\n \"comment\": \"The E2E tests will silently prefer any `cli-anything-wavetone` found in `PATH`, which can make the suite run against an older/foreign installed version instead of the code under test. Consider defaulting to `python -m cli_anything.wavetone.wavetone_cli` and only using the installed entry point when explicitly requested (e.g., `CLI_ANYTHING_FORCE_INSTALLED=1`).\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\",\n \"hunk\": \"@@ -0,0 +1,144 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shutil\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.tests.helpers import make_wav\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+REAL_BACKEND_ENV = \\\"CLI_ANYTHING_WAVETONE_REAL_BACKEND\\\"\\n+\\n+\\n+def _resolve_cli(name: str) -> list[str]:\\n+ \\\"\\\"\\\"Resolve installed CLI command; fall back to python -m for development.\\\"\\\"\\\"\\n+ force = os.environ.get(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"\\\").strip() == \\\"1\\\"\\n+ path = shutil.which(name)\\n+ if path:\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+ if force:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ print(f\\\"[_resolve_cli] Falling back to: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\nnew file mode 100644\\nindex 000000000..2ceb45661\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\n@@ -0,0 +1,153 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shutil\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.tests.helpers import make_wav\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+REAL_BACKEND_ENV = \\\"CLI_ANYTHING_WAVETONE_REAL_BACKEND\\\"\\n+\\n+\\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\\n+ \\\"\\\"\\\"Run the in-tree module by default; installed entry points are opt-in.\\\"\\\"\\\"\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ if not force_installed:\\n+ print(f\\\"[_resolve_cli] Using source module: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+ path = shutil.which(name)\\n+ if not path:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+\\n+\\n+def _env_flag_enabled(name: str) -> bool:\\n+ return os.environ.get(name, \\\"\\\").strip().lower() in {\\\"1\\\", \\\"true\\\", \\\"yes\\\", \\\"on\\\"}\\n+\\n+\\n+def _real_backend_ready() -> tuple[bool, str]:\\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\\n+ return False, f\\\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+ if sys.platform != \\\"win32\\\":\\n+ return False, \\\"WaveTone real-backend tests require Windows\\\"\\n+ if not (os.environ.get(\\\"WAVETONE_EXE\\\") or os.environ.get(\\\"WAVETONE_HOME\\\")):\\n+ return False, \\\"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+\\n+ status = wavetone_backend.doctor()\\n+ if status.get(\\\"ready\\\"):\\n+ return True, \\\"\\\"\\n+\\n+ failed_checks = [check[\\\"name\\\"] for check in status.get(\\\"checks\\\", []) if not check.get(\\\"ok\\\")]\\n+ reason = \\\", \\\".join(failed_checks) if failed_checks else \\\"WaveTone backend is not ready\\\"\\n+ return False, f\\\"WaveTone real backend unavailable: {reason}\\\"\\n+\\n+\\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\\n+\\n+\\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_EXE\\\", raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_HOME\\\", raising=False)\\n+\\n+ ready, reason = _real_backend_ready()\\n+\\n+ assert ready is False\\n+ assert REAL_BACKEND_ENV in reason\\n+\\n+\\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setenv(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"1\\\")\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: pytest.fail(\\\"default resolver should not inspect PATH\\\"))\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\") == [sys.executable, \\\"-m\\\", \\\"cli_anything.wavetone.wavetone_cli\\\"]\\n+\\n+\\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: \\\"C:/installed/cli-anything-wavetone.exe\\\")\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\", force_installed=True) == [\\\"C:/installed/cli-anything-wavetone.exe\\\"]\\n+\\n+\\n+class TestCLISubprocess:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_help(self) -> None:\\n+ result = self._run([\\\"--help\\\"])\\n+ assert \\\"Agent-native CLI harness for WaveTone\\\" in result.stdout\\n+\\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\\n+ wav = make_wav(tmp_path / \\\"tone.wav\\\")\\n+ project = tmp_path / \\\"tone.wt.json\\\"\\n+\\n+ result = self._run([\\\"--json\\\", \\\"project\\\", \\\"new\\\", str(wav), \\\"-o\\\", str(project)])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ok\\\"] is True\\n+ assert project.exists()\\n+\\n+ result = self._run(\\n+ [\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"set-tempo\\\", \\\"--bpm\\\", \\\"132.5\\\", \\\"--first-bar\\\", \\\"0.1\\\"]\\n+ )\\n+ assert json.loads(result.stdout)[\\\"tempo\\\"][\\\"bpm\\\"] == 132.5\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"add-label\\\", \\\"intro\\\", \\\"--time\\\", \\\"0.25\\\"])\\n+ assert json.loads(result.stdout)[\\\"labels\\\"][0][\\\"name\\\"] == \\\"intro\\\"\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"audio\\\", \\\"probe\\\"])\\n+ audio = json.loads(result.stdout)[\\\"audio\\\"]\\n+ assert audio[\\\"duration_seconds\\\"] == 0.5\\n+ assert audio[\\\"channels\\\"] == 1\\n+ print(f\\\"\\\\n Project: {project}\\\")\\n+ print(f\\\" Audio: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n+\\n+ def test_formats_json(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"formats\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert \\\".wav\\\" in data[\\\"formats\\\"][\\\"extensions\\\"]\\n+ assert \\\"MP3\\\" in data[\\\"formats\\\"][\\\"from_readme\\\"]\\n+\\n+\\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\\n+class TestRealWaveToneBackend:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_doctor_real_backend(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"doctor\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ready\\\"] is True\\n+ assert any(check[\\\"name\\\"] == \\\"data/asdecoder.exe\\\" and check[\\\"ok\\\"] for check in data[\\\"checks\\\"])\\n+ print(f\\\"\\\\n WaveTone root: {data['root']}\\\")\\n+\\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\\n+ exe = wavetone_backend.find_wavetone()\\n+ wav = make_wav(tmp_path / \\\"launch.wav\\\")\\n+ result = self._run(\\n+ [\\n+ \\\"--json\\\",\\n+ \\\"wavetone\\\",\\n+ \\\"launch\\\",\\n+ str(wav),\\n+ \\\"--exe\\\",\\n+ str(exe),\\n+ \\\"--wait\\\",\\n+ \\\"1\\\",\\n+ \\\"--terminate\\\",\\n+ ]\\n+ )\\n+ data = json.loads(result.stdout)[\\\"launch\\\"]\\n+ assert data[\\\"backend\\\"] == \\\"wavetone.exe\\\"\\n+ assert data[\\\"audio_path\\\"] == str(wav.resolve())\\n+ assert data[\\\"running_after_wait\\\"] is True\\n+ assert data[\\\"terminated\\\"] is True\\n+ print(f\\\"\\\\n Launched WaveTone PID: {data['pid']}\\\")\\n+ print(f\\\" WAV: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n\"\n },\n {\n \"comment\": \"Passing `\\\\\\\"wavetone\\\\\\\"` causes `ReplSkin` to derive a title-cased display name of `\\\\\\\"Wavetone\\\\\\\"`, which likely doesn’t match the product branding `\\\\\\\"WaveTone\\\\\\\"`. Consider passing `\\\\\\\"WaveTone\\\\\\\"` here (or adding a per-software display-name override in `ReplSkin`) to keep user-visible output consistent.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,369 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"wavetone\\\", version=__version__)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n },\n {\n \"comment\": \"`self.skill_path` is computed and stored but not referenced anywhere else in this file (the banner currently prints `global_skill_path` instead). Either remove this unused detection to reduce complexity, or incorporate `self.skill_path` into the banner output so it has a clear purpose.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\",\n \"hunk\": \"@@ -0,0 +1,565 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ self.display_name = software.replace(\\\"_\\\", \\\" \\\").title()\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\nnew file mode 100644\\nindex 000000000..3296206c8\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/utils/repl_skin.py\\n@@ -0,0 +1,568 @@\\n+\\\"\\\"\\\"cli-anything REPL Skin — Unified terminal interface for all CLI harnesses.\\n+\\n+Copy this file into your CLI package at:\\n+ cli_anything/<software>/utils/repl_skin.py\\n+\\n+Usage:\\n+ from cli_anything.<software>.utils.repl_skin import ReplSkin\\n+\\n+ skin = ReplSkin(\\\"shotcut\\\", version=\\\"1.0.0\\\")\\n+ skin.print_banner() # auto-detects repo-root or packaged SKILL.md\\n+ prompt_text = skin.prompt(project_name=\\\"my_video.mlt\\\", modified=True)\\n+ skin.success(\\\"Project saved\\\")\\n+ skin.error(\\\"File not found\\\")\\n+ skin.warning(\\\"Unsaved changes\\\")\\n+ skin.info(\\\"Processing 24 clips...\\\")\\n+ skin.status(\\\"Track 1\\\", \\\"3 clips, 00:02:30\\\")\\n+ skin.table(headers, rows)\\n+ skin.print_goodbye()\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+import sys\\n+from pathlib import Path\\n+\\n+# ── ANSI color codes (no external deps for core styling) ──────────────\\n+\\n+_RESET = \\\"\\\\033[0m\\\"\\n+_BOLD = \\\"\\\\033[1m\\\"\\n+_DIM = \\\"\\\\033[2m\\\"\\n+_ITALIC = \\\"\\\\033[3m\\\"\\n+_UNDERLINE = \\\"\\\\033[4m\\\"\\n+\\n+# Brand colors\\n+_CYAN = \\\"\\\\033[38;5;80m\\\" # cli-anything brand cyan\\n+_CYAN_BG = \\\"\\\\033[48;5;80m\\\"\\n+_WHITE = \\\"\\\\033[97m\\\"\\n+_GRAY = \\\"\\\\033[38;5;245m\\\"\\n+_DARK_GRAY = \\\"\\\\033[38;5;240m\\\"\\n+_LIGHT_GRAY = \\\"\\\\033[38;5;250m\\\"\\n+\\n+# Software accent colors — each software gets a unique accent\\n+_ACCENT_COLORS = {\\n+ \\\"gimp\\\": \\\"\\\\033[38;5;214m\\\", # warm orange\\n+ \\\"blender\\\": \\\"\\\\033[38;5;208m\\\", # deep orange\\n+ \\\"inkscape\\\": \\\"\\\\033[38;5;39m\\\", # bright blue\\n+ \\\"audacity\\\": \\\"\\\\033[38;5;33m\\\", # navy blue\\n+ \\\"libreoffice\\\": \\\"\\\\033[38;5;40m\\\", # green\\n+ \\\"obs_studio\\\": \\\"\\\\033[38;5;55m\\\", # purple\\n+ \\\"kdenlive\\\": \\\"\\\\033[38;5;69m\\\", # slate blue\\n+ \\\"shotcut\\\": \\\"\\\\033[38;5;35m\\\", # teal green\\n+}\\n+_DEFAULT_ACCENT = \\\"\\\\033[38;5;75m\\\" # default sky blue\\n+\\n+# Status colors\\n+_GREEN = \\\"\\\\033[38;5;78m\\\"\\n+_YELLOW = \\\"\\\\033[38;5;220m\\\"\\n+_RED = \\\"\\\\033[38;5;196m\\\"\\n+_BLUE = \\\"\\\\033[38;5;75m\\\"\\n+_MAGENTA = \\\"\\\\033[38;5;176m\\\"\\n+\\n+_SKILL_SOURCE_REPO = os.environ.get(\\\"CLI_ANYTHING_SKILL_REPO\\\", \\\"HKUDS/CLI-Anything\\\")\\n+\\n+# ── Brand icon ────────────────────────────────────────────────────────\\n+\\n+# The cli-anything icon: a small colored diamond/chevron mark\\n+_ICON = f\\\"{_CYAN}{_BOLD}◆{_RESET}\\\"\\n+_ICON_SMALL = f\\\"{_CYAN}▸{_RESET}\\\"\\n+\\n+# ── Box drawing characters ────────────────────────────────────────────\\n+\\n+_H_LINE = \\\"─\\\"\\n+_V_LINE = \\\"│\\\"\\n+_TL = \\\"╭\\\"\\n+_TR = \\\"╮\\\"\\n+_BL = \\\"╰\\\"\\n+_BR = \\\"╯\\\"\\n+_T_DOWN = \\\"┬\\\"\\n+_T_UP = \\\"┴\\\"\\n+_T_RIGHT = \\\"├\\\"\\n+_T_LEFT = \\\"┤\\\"\\n+_CROSS = \\\"┼\\\"\\n+\\n+\\n+def _strip_ansi(text: str) -> str:\\n+ \\\"\\\"\\\"Remove ANSI escape codes for length calculation.\\\"\\\"\\\"\\n+ import re\\n+ return re.sub(r\\\"\\\\033\\\\[[^m]*m\\\", \\\"\\\", text)\\n+\\n+\\n+def _visible_len(text: str) -> int:\\n+ \\\"\\\"\\\"Get visible length of text (excluding ANSI codes).\\\"\\\"\\\"\\n+ return len(_strip_ansi(text))\\n+\\n+\\n+def _display_home_path(path: str) -> str:\\n+ \\\"\\\"\\\"Display a path relative to the home directory when possible.\\\"\\\"\\\"\\n+ expanded = Path(path).expanduser().resolve()\\n+ home = Path.home().resolve()\\n+ try:\\n+ relative = expanded.relative_to(home)\\n+ return f\\\"~/{relative.as_posix()}\\\"\\n+ except ValueError:\\n+ return str(expanded)\\n+\\n+\\n+class ReplSkin:\\n+ \\\"\\\"\\\"Unified REPL skin for cli-anything CLIs.\\n+\\n+ Provides consistent branding, prompts, and message formatting\\n+ across all CLI harnesses built with the cli-anything methodology.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, software: str, version: str = \\\"1.0.0\\\",\\n+ history_file: str | None = None, skill_path: str | None = None):\\n+ \\\"\\\"\\\"Initialize the REPL skin.\\n+\\n+ Args:\\n+ software: Software name (e.g., \\\"gimp\\\", \\\"shotcut\\\", \\\"blender\\\").\\n+ version: CLI version string.\\n+ history_file: Path for persistent command history.\\n+ Defaults to ~/.cli-anything-<software>/history\\n+ skill_path: Path to the SKILL.md file for agent discovery.\\n+ Auto-detected from the repo-root skills/ tree when present,\\n+ otherwise from the package's skills/ directory.\\n+ Displayed in banner for AI agents to know where to read skill info.\\n+ \\\"\\\"\\\"\\n+ self.software = software.lower().replace(\\\"-\\\", \\\"_\\\")\\n+ display_overrides = {\\\"wavetone\\\": \\\"WaveTone\\\"}\\n+ self.display_name = display_overrides.get(self.software, software.replace(\\\"_\\\", \\\" \\\").title())\\n+ self.version = version\\n+ software_aliases = {\\\"iterm2_ctl\\\": \\\"iterm2\\\"}\\n+ self.skill_slug = software_aliases.get(self.software, self.software).replace(\\\"_\\\", \\\"-\\\")\\n+ self.skill_id = f\\\"cli-anything-{self.skill_slug}\\\"\\n+ self.skill_install_cmd = (\\n+ f\\\"npx skills add {_SKILL_SOURCE_REPO} --skill {self.skill_id} -g -y\\\"\\n+ )\\n+ global_skill_root = Path(\\n+ os.environ.get(\\\"CLI_ANYTHING_GLOBAL_SKILLS_DIR\\\", str(Path.home() / \\\".agents\\\" / \\\"skills\\\"))\\n+ ).expanduser()\\n+ self.global_skill_path = str(global_skill_root / self.skill_id / \\\"SKILL.md\\\")\\n+\\n+ # Prefer repo-root canonical skills/<skill-id>/SKILL.md when running\\n+ # inside the CLI-Anything monorepo. Fall back to the packaged\\n+ # cli_anything/<software>/skills/SKILL.md for installed harnesses.\\n+ if skill_path is None:\\n+ package_skill = Path(__file__).resolve().parent.parent / \\\"skills\\\" / \\\"SKILL.md\\\"\\n+ repo_skill = None\\n+ for parent in Path(__file__).resolve().parents:\\n+ candidate = parent / \\\"skills\\\" / self.skill_id / \\\"SKILL.md\\\"\\n+ if candidate.is_file():\\n+ repo_skill = candidate\\n+ break\\n+ if repo_skill and repo_skill.is_file():\\n+ skill_path = str(repo_skill)\\n+ elif package_skill.is_file():\\n+ skill_path = str(package_skill)\\n+ self.skill_path = skill_path\\n+ self.accent = _ACCENT_COLORS.get(self.software, _DEFAULT_ACCENT)\\n+\\n+ # History file\\n+ if history_file is None:\\n+ hist_dir = Path.home() / f\\\".cli-anything-{self.software}\\\"\\n+ hist_dir.mkdir(parents=True, exist_ok=True)\\n+ self.history_file = str(hist_dir / \\\"history\\\")\\n+ else:\\n+ self.history_file = history_file\\n+\\n+ # Detect terminal capabilities\\n+ self._color = self._detect_color_support()\\n+\\n+ def _detect_color_support(self) -> bool:\\n+ \\\"\\\"\\\"Check if terminal supports color.\\\"\\\"\\\"\\n+ if os.environ.get(\\\"NO_COLOR\\\"):\\n+ return False\\n+ if os.environ.get(\\\"CLI_ANYTHING_NO_COLOR\\\"):\\n+ return False\\n+ if not hasattr(sys.stdout, \\\"isatty\\\"):\\n+ return False\\n+ return sys.stdout.isatty()\\n+\\n+ def _c(self, code: str, text: str) -> str:\\n+ \\\"\\\"\\\"Apply color code if colors are supported.\\\"\\\"\\\"\\n+ if not self._color:\\n+ return text\\n+ return f\\\"{code}{text}{_RESET}\\\"\\n+\\n+ # ── Banner ────────────────────────────────────────────────────────\\n+\\n+ def print_banner(self):\\n+ \\\"\\\"\\\"Print the startup banner with branding.\\\"\\\"\\\"\\n+ import textwrap\\n+\\n+ inner = 72\\n+\\n+ def _box_line(content: str) -> str:\\n+ \\\"\\\"\\\"Wrap content in box drawing, padding to inner width.\\\"\\\"\\\"\\n+ pad = inner - _visible_len(content)\\n+ vl = self._c(_DARK_GRAY, _V_LINE)\\n+ return f\\\"{vl}{content}{' ' * max(0, pad)}{vl}\\\"\\n+\\n+ def _meta_lines(label: str, value: str) -> list[str]:\\n+ \\\"\\\"\\\"Wrap a metadata line for the banner box.\\\"\\\"\\\"\\n+ icon = self._c(_MAGENTA, \\\"◇\\\")\\n+ label_text = self._c(_DARK_GRAY, label)\\n+ prefix = f\\\" {icon} {label_text} \\\"\\n+ available = max(12, inner - _visible_len(prefix))\\n+ wrapped = textwrap.wrap(\\n+ value,\\n+ width=available,\\n+ break_long_words=True,\\n+ break_on_hyphens=False,\\n+ ) or [\\\"\\\"]\\n+ lines = [f\\\"{prefix}{self._c(_LIGHT_GRAY, wrapped[0])}\\\"]\\n+ continuation_prefix = \\\" \\\" * _visible_len(prefix)\\n+ for chunk in wrapped[1:]:\\n+ lines.append(f\\\"{continuation_prefix}{self._c(_LIGHT_GRAY, chunk)}\\\")\\n+ return lines\\n+\\n+ top = self._c(_DARK_GRAY, f\\\"{_TL}{_H_LINE * inner}{_TR}\\\")\\n+ bot = self._c(_DARK_GRAY, f\\\"{_BL}{_H_LINE * inner}{_BR}\\\")\\n+\\n+ # Title: ◆ cli-anything · Shotcut\\n+ icon = self._c(_CYAN + _BOLD, \\\"◆\\\")\\n+ brand = self._c(_CYAN + _BOLD, \\\"cli-anything\\\")\\n+ dot = self._c(_DARK_GRAY, \\\"·\\\")\\n+ name = self._c(self.accent + _BOLD, self.display_name)\\n+ title = f\\\" {icon} {brand} {dot} {name}\\\"\\n+\\n+ ver = f\\\" {self._c(_DARK_GRAY, f' v{self.version}')}\\\"\\n+ tip = f\\\" {self._c(_DARK_GRAY, ' Type help for commands, quit to exit')}\\\"\\n+ empty = \\\"\\\"\\n+\\n+ meta_lines: list[str] = []\\n+ meta_lines.extend(_meta_lines(\\\"Install:\\\", self.skill_install_cmd))\\n+ if self.skill_path:\\n+ meta_lines.extend(_meta_lines(\\\"Local skill:\\\", _display_home_path(self.skill_path)))\\n+ meta_lines.extend(_meta_lines(\\\"Global skill:\\\", _display_home_path(self.global_skill_path)))\\n+ print(top)\\n+ print(_box_line(title))\\n+ print(_box_line(ver))\\n+ for line in meta_lines:\\n+ print(_box_line(line))\\n+ print(_box_line(empty))\\n+ print(_box_line(tip))\\n+ print(bot)\\n+ print()\\n+\\n+ # ── Prompt ────────────────────────────────────────────────────────\\n+\\n+ def prompt(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a styled prompt string for prompt_toolkit or input().\\n+\\n+ Args:\\n+ project_name: Current project name (empty if none open).\\n+ modified: Whether the project has unsaved changes.\\n+ context: Optional extra context to show in prompt.\\n+\\n+ Returns:\\n+ Formatted prompt string.\\n+ \\\"\\\"\\\"\\n+ parts = []\\n+\\n+ # Icon\\n+ if self._color:\\n+ parts.append(f\\\"{_CYAN}◆{_RESET} \\\")\\n+ else:\\n+ parts.append(\\\"> \\\")\\n+\\n+ # Software name\\n+ parts.append(self._c(self.accent + _BOLD, self.software))\\n+\\n+ # Project context\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ parts.append(f\\\" {self._c(_DARK_GRAY, '[')}\\\")\\n+ parts.append(self._c(_LIGHT_GRAY, f\\\"{ctx}{mod}\\\"))\\n+ parts.append(self._c(_DARK_GRAY, ']'))\\n+\\n+ parts.append(self._c(_GRAY, \\\" ❯ \\\"))\\n+\\n+ return \\\"\\\".join(parts)\\n+\\n+ def prompt_tokens(self, project_name: str = \\\"\\\", modified: bool = False,\\n+ context: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Build prompt_toolkit formatted text tokens for the prompt.\\n+\\n+ Use with prompt_toolkit's FormattedText for proper ANSI handling.\\n+\\n+ Returns:\\n+ list of (style, text) tuples for prompt_toolkit.\\n+ \\\"\\\"\\\"\\n+ tokens = []\\n+\\n+ tokens.append((\\\"class:icon\\\", \\\"◆ \\\"))\\n+ tokens.append((\\\"class:software\\\", self.software))\\n+\\n+ if project_name or context:\\n+ ctx = context or project_name\\n+ mod = \\\"*\\\" if modified else \\\"\\\"\\n+ tokens.append((\\\"class:bracket\\\", \\\" [\\\"))\\n+ tokens.append((\\\"class:context\\\", f\\\"{ctx}{mod}\\\"))\\n+ tokens.append((\\\"class:bracket\\\", \\\"]\\\"))\\n+\\n+ tokens.append((\\\"class:arrow\\\", \\\" ❯ \\\"))\\n+\\n+ return tokens\\n+\\n+ def get_prompt_style(self):\\n+ \\\"\\\"\\\"Get a prompt_toolkit Style object matching the skin.\\n+\\n+ Returns:\\n+ prompt_toolkit.styles.Style\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit.styles import Style\\n+ except ImportError:\\n+ return None\\n+\\n+ accent_hex = _ANSI_256_TO_HEX.get(self.accent, \\\"#5fafff\\\")\\n+\\n+ return Style.from_dict({\\n+ \\\"icon\\\": \\\"#5fdfdf bold\\\", # cyan brand color\\n+ \\\"software\\\": f\\\"{accent_hex} bold\\\",\\n+ \\\"bracket\\\": \\\"#585858\\\",\\n+ \\\"context\\\": \\\"#bcbcbc\\\",\\n+ \\\"arrow\\\": \\\"#808080\\\",\\n+ # Completion menu\\n+ \\\"completion-menu.completion\\\": \\\"bg:#303030 #bcbcbc\\\",\\n+ \\\"completion-menu.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ \\\"completion-menu.meta.completion\\\": \\\"bg:#303030 #808080\\\",\\n+ \\\"completion-menu.meta.completion.current\\\": f\\\"bg:{accent_hex} #000000\\\",\\n+ # Auto-suggest\\n+ \\\"auto-suggest\\\": \\\"#585858\\\",\\n+ # Bottom toolbar\\n+ \\\"bottom-toolbar\\\": \\\"bg:#1c1c1c #808080\\\",\\n+ \\\"bottom-toolbar.text\\\": \\\"#808080\\\",\\n+ })\\n+\\n+ # ── Messages ──────────────────────────────────────────────────────\\n+\\n+ def success(self, message: str):\\n+ \\\"\\\"\\\"Print a success message with green checkmark.\\\"\\\"\\\"\\n+ icon = self._c(_GREEN + _BOLD, \\\"✓\\\")\\n+ print(f\\\" {icon} {self._c(_GREEN, message)}\\\")\\n+\\n+ def error(self, message: str):\\n+ \\\"\\\"\\\"Print an error message with red cross.\\\"\\\"\\\"\\n+ icon = self._c(_RED + _BOLD, \\\"✗\\\")\\n+ print(f\\\" {icon} {self._c(_RED, message)}\\\", file=sys.stderr)\\n+\\n+ def warning(self, message: str):\\n+ \\\"\\\"\\\"Print a warning message with yellow triangle.\\\"\\\"\\\"\\n+ icon = self._c(_YELLOW + _BOLD, \\\"⚠\\\")\\n+ print(f\\\" {icon} {self._c(_YELLOW, message)}\\\")\\n+\\n+ def info(self, message: str):\\n+ \\\"\\\"\\\"Print an info message with blue dot.\\\"\\\"\\\"\\n+ icon = self._c(_BLUE, \\\"●\\\")\\n+ print(f\\\" {icon} {self._c(_LIGHT_GRAY, message)}\\\")\\n+\\n+ def hint(self, message: str):\\n+ \\\"\\\"\\\"Print a subtle hint message.\\\"\\\"\\\"\\n+ print(f\\\" {self._c(_DARK_GRAY, message)}\\\")\\n+\\n+ def section(self, title: str):\\n+ \\\"\\\"\\\"Print a section header.\\\"\\\"\\\"\\n+ print()\\n+ print(f\\\" {self._c(self.accent + _BOLD, title)}\\\")\\n+ print(f\\\" {self._c(_DARK_GRAY, _H_LINE * len(title))}\\\")\\n+\\n+ # ── Status display ────────────────────────────────────────────────\\n+\\n+ def status(self, label: str, value: str):\\n+ \\\"\\\"\\\"Print a key-value status line.\\\"\\\"\\\"\\n+ lbl = self._c(_GRAY, f\\\" {label}:\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def status_block(self, items: dict[str, str], title: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a block of status key-value pairs.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs.\\n+ title: Optional title for the block.\\n+ \\\"\\\"\\\"\\n+ if title:\\n+ self.section(title)\\n+\\n+ max_key = max(len(k) for k in items) if items else 0\\n+ for label, value in items.items():\\n+ lbl = self._c(_GRAY, f\\\" {label:<{max_key}}\\\")\\n+ val = self._c(_WHITE, f\\\" {value}\\\")\\n+ print(f\\\"{lbl}{val}\\\")\\n+\\n+ def progress(self, current: int, total: int, label: str = \\\"\\\"):\\n+ \\\"\\\"\\\"Print a simple progress indicator.\\n+\\n+ Args:\\n+ current: Current step number.\\n+ total: Total number of steps.\\n+ label: Optional label for the progress.\\n+ \\\"\\\"\\\"\\n+ pct = int(current / total * 100) if total > 0 else 0\\n+ bar_width = 20\\n+ filled = int(bar_width * current / total) if total > 0 else 0\\n+ bar = \\\"█\\\" * filled + \\\"░\\\" * (bar_width - filled)\\n+ text = f\\\" {self._c(_CYAN, bar)} {self._c(_GRAY, f'{pct:3d}%')}\\\"\\n+ if label:\\n+ text += f\\\" {self._c(_LIGHT_GRAY, label)}\\\"\\n+ print(text)\\n+\\n+ # ── Table display ─────────────────────────────────────────────────\\n+\\n+ def table(self, headers: list[str], rows: list[list[str]],\\n+ max_col_width: int = 40):\\n+ \\\"\\\"\\\"Print a formatted table with box-drawing characters.\\n+\\n+ Args:\\n+ headers: Column header strings.\\n+ rows: List of rows, each a list of cell strings.\\n+ max_col_width: Maximum column width before truncation.\\n+ \\\"\\\"\\\"\\n+ if not headers:\\n+ return\\n+\\n+ # Calculate column widths\\n+ col_widths = [min(len(h), max_col_width) for h in headers]\\n+ for row in rows:\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ col_widths[i] = min(\\n+ max(col_widths[i], len(str(cell))), max_col_width\\n+ )\\n+\\n+ def pad(text: str, width: int) -> str:\\n+ t = str(text)[:width]\\n+ return t + \\\" \\\" * (width - len(t))\\n+\\n+ # Header\\n+ header_cells = [\\n+ self._c(_CYAN + _BOLD, pad(h, col_widths[i]))\\n+ for i, h in enumerate(headers)\\n+ ]\\n+ sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ header_line = f\\\" {sep.join(header_cells)}\\\"\\n+ print(header_line)\\n+\\n+ # Separator\\n+ sep_parts = [self._c(_DARK_GRAY, _H_LINE * w) for w in col_widths]\\n+ sep_line = f\\\" {sep.join(sep_parts)}\\\"\\n+ print(sep_line)\\n+\\n+ # Rows\\n+ for row in rows:\\n+ cells = []\\n+ for i, cell in enumerate(row):\\n+ if i < len(col_widths):\\n+ cells.append(self._c(_LIGHT_GRAY, pad(str(cell), col_widths[i])))\\n+ row_sep = self._c(_DARK_GRAY, f\\\" {_V_LINE} \\\")\\n+ print(f\\\" {row_sep.join(cells)}\\\")\\n+\\n+ # ── Help display ──────────────────────────────────────────────────\\n+\\n+ def help(self, commands: dict[str, str]):\\n+ \\\"\\\"\\\"Print a formatted help listing.\\n+\\n+ Args:\\n+ commands: Dict of command -> description pairs.\\n+ \\\"\\\"\\\"\\n+ self.section(\\\"Commands\\\")\\n+ max_cmd = max(len(c) for c in commands) if commands else 0\\n+ for cmd, desc in commands.items():\\n+ cmd_styled = self._c(self.accent, f\\\" {cmd:<{max_cmd}}\\\")\\n+ desc_styled = self._c(_GRAY, f\\\" {desc}\\\")\\n+ print(f\\\"{cmd_styled}{desc_styled}\\\")\\n+ print()\\n+\\n+ # ── Goodbye ───────────────────────────────────────────────────────\\n+\\n+ def print_goodbye(self):\\n+ \\\"\\\"\\\"Print a styled goodbye message.\\\"\\\"\\\"\\n+ print(f\\\"\\\\n {_ICON_SMALL} {self._c(_GRAY, 'Goodbye!')}\\\\n\\\")\\n+\\n+ # ── Prompt toolkit session factory ────────────────────────────────\\n+\\n+ def create_prompt_session(self):\\n+ \\\"\\\"\\\"Create a prompt_toolkit PromptSession with skin styling.\\n+\\n+ Returns:\\n+ A configured PromptSession, or None if prompt_toolkit unavailable.\\n+ \\\"\\\"\\\"\\n+ try:\\n+ from prompt_toolkit import PromptSession\\n+ from prompt_toolkit.history import FileHistory\\n+ from prompt_toolkit.auto_suggest import AutoSuggestFromHistory\\n+\\n+ style = self.get_prompt_style()\\n+\\n+ session = PromptSession(\\n+ history=FileHistory(self.history_file),\\n+ auto_suggest=AutoSuggestFromHistory(),\\n+ style=style,\\n+ enable_history_search=True,\\n+ )\\n+ return session\\n+ except ImportError:\\n+ return None\\n+\\n+ def get_input(self, pt_session, project_name: str = \\\"\\\",\\n+ modified: bool = False, context: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Get input from user using prompt_toolkit or fallback.\\n+\\n+ Args:\\n+ pt_session: A prompt_toolkit PromptSession (or None).\\n+ project_name: Current project name.\\n+ modified: Whether project has unsaved changes.\\n+ context: Optional context string.\\n+\\n+ Returns:\\n+ User input string (stripped).\\n+ \\\"\\\"\\\"\\n+ if pt_session is not None:\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ tokens = self.prompt_tokens(project_name, modified, context)\\n+ return pt_session.prompt(FormattedText(tokens)).strip()\\n+ else:\\n+ raw_prompt = self.prompt(project_name, modified, context)\\n+ return input(raw_prompt).strip()\\n+\\n+ # ── Toolbar builder ───────────────────────────────────────────────\\n+\\n+ def bottom_toolbar(self, items: dict[str, str]):\\n+ \\\"\\\"\\\"Create a bottom toolbar callback for prompt_toolkit.\\n+\\n+ Args:\\n+ items: Dict of label -> value pairs to show in toolbar.\\n+\\n+ Returns:\\n+ A callable that returns FormattedText for the toolbar.\\n+ \\\"\\\"\\\"\\n+ def toolbar():\\n+ from prompt_toolkit.formatted_text import FormattedText\\n+ parts = []\\n+ for i, (k, v) in enumerate(items.items()):\\n+ if i > 0:\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", \\\" │ \\\"))\\n+ parts.append((\\\"class:bottom-toolbar.text\\\", f\\\" {k}: \\\"))\\n+ parts.append((\\\"class:bottom-toolbar\\\", v))\\n+ return FormattedText(parts)\\n+ return toolbar\\n+\\n+\\n+# ── ANSI 256-color to hex mapping (for prompt_toolkit styles) ─────────\\n+\\n+_ANSI_256_TO_HEX = {\\n+ \\\"\\\\033[38;5;33m\\\": \\\"#0087ff\\\", # audacity navy blue\\n+ \\\"\\\\033[38;5;35m\\\": \\\"#00af5f\\\", # shotcut teal\\n+ \\\"\\\\033[38;5;39m\\\": \\\"#00afff\\\", # inkscape bright blue\\n+ \\\"\\\\033[38;5;40m\\\": \\\"#00d700\\\", # libreoffice green\\n+ \\\"\\\\033[38;5;55m\\\": \\\"#5f00af\\\", # obs purple\\n+ \\\"\\\\033[38;5;69m\\\": \\\"#5f87ff\\\", # kdenlive slate blue\\n+ \\\"\\\\033[38;5;75m\\\": \\\"#5fafff\\\", # default sky blue\\n+ \\\"\\\\033[38;5;80m\\\": \\\"#5fd7d7\\\", # brand cyan\\n+ \\\"\\\\033[38;5;208m\\\": \\\"#ff8700\\\", # blender deep orange\\n+ \\\"\\\\033[38;5;214m\\\": \\\"#ffaf00\\\", # gimp warm orange\\n+}\\n\"\n },\n {\n \"comment\": \"`CLI_BASE` is computed at import/collection time and depends on the ambient `CLI_ANYTHING_FORCE_INSTALLED` environment variable. If a developer/CI environment has that variable set, this test class will switch to the installed entry point and can fail unexpectedly (e.g., binary not installed), even though the suite intends source-module default behavior. Consider resolving the CLI base inside `_run()` (or via a fixture) after explicitly clearing/controlling `CLI_ANYTHING_FORCE_INSTALLED`, so the tests are deterministic regardless of external env.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\",\n \"hunk\": \"@@ -0,0 +1,152 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shutil\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.tests.helpers import make_wav\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+REAL_BACKEND_ENV = \\\"CLI_ANYTHING_WAVETONE_REAL_BACKEND\\\"\\n+\\n+\\n+def _resolve_cli(name: str) -> list[str]:\\n+ \\\"\\\"\\\"Run the in-tree module by default; installed entry points are opt-in.\\\"\\\"\\\"\\n+ force = os.environ.get(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"\\\").strip() == \\\"1\\\"\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ if not force:\\n+ print(f\\\"[_resolve_cli] Using source module: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+ path = shutil.which(name)\\n+ if not path:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+\\n+\\n+def _env_flag_enabled(name: str) -> bool:\\n+ return os.environ.get(name, \\\"\\\").strip().lower() in {\\\"1\\\", \\\"true\\\", \\\"yes\\\", \\\"on\\\"}\\n+\\n+\\n+def _real_backend_ready() -> tuple[bool, str]:\\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\\n+ return False, f\\\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+ if sys.platform != \\\"win32\\\":\\n+ return False, \\\"WaveTone real-backend tests require Windows\\\"\\n+ if not (os.environ.get(\\\"WAVETONE_EXE\\\") or os.environ.get(\\\"WAVETONE_HOME\\\")):\\n+ return False, \\\"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+\\n+ status = wavetone_backend.doctor()\\n+ if status.get(\\\"ready\\\"):\\n+ return True, \\\"\\\"\\n+\\n+ failed_checks = [check[\\\"name\\\"] for check in status.get(\\\"checks\\\", []) if not check.get(\\\"ok\\\")]\\n+ reason = \\\", \\\".join(failed_checks) if failed_checks else \\\"WaveTone backend is not ready\\\"\\n+ return False, f\\\"WaveTone real backend unavailable: {reason}\\\"\\n+\\n+\\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\\n+\\n+\\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_EXE\\\", raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_HOME\\\", raising=False)\\n+\\n+ ready, reason = _real_backend_ready()\\n+\\n+ assert ready is False\\n+ assert REAL_BACKEND_ENV in reason\\n+\\n+\\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.delenv(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", raising=False)\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: \\\"C:/foreign/cli-anything-wavetone.exe\\\")\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\") == [sys.executable, \\\"-m\\\", \\\"cli_anything.wavetone.wavetone_cli\\\"]\\n+\\n+\\n+class TestCLISubprocess:\\n+ CLI_BASE = _resolve_cli(\\\"cli-anything-wavetone\\\")\\n+\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(self.CLI_BASE + args, capture_output=True, text=True, check=check)\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\nnew file mode 100644\\nindex 000000000..2ceb45661\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\\n@@ -0,0 +1,153 @@\\n+from __future__ import annotations\\n+\\n+import json\\n+import os\\n+import shutil\\n+import subprocess\\n+import sys\\n+from pathlib import Path\\n+\\n+import pytest\\n+\\n+from cli_anything.wavetone.tests.helpers import make_wav\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+\\n+REAL_BACKEND_ENV = \\\"CLI_ANYTHING_WAVETONE_REAL_BACKEND\\\"\\n+\\n+\\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\\n+ \\\"\\\"\\\"Run the in-tree module by default; installed entry points are opt-in.\\\"\\\"\\\"\\n+ module = \\\"cli_anything.wavetone.wavetone_cli\\\"\\n+ if not force_installed:\\n+ print(f\\\"[_resolve_cli] Using source module: {sys.executable} -m {module}\\\")\\n+ return [sys.executable, \\\"-m\\\", module]\\n+\\n+ path = shutil.which(name)\\n+ if not path:\\n+ raise RuntimeError(f\\\"{name} not found in PATH. Install with: pip install -e .\\\")\\n+ print(f\\\"[_resolve_cli] Using installed command: {path}\\\")\\n+ return [path]\\n+\\n+\\n+def _env_flag_enabled(name: str) -> bool:\\n+ return os.environ.get(name, \\\"\\\").strip().lower() in {\\\"1\\\", \\\"true\\\", \\\"yes\\\", \\\"on\\\"}\\n+\\n+\\n+def _real_backend_ready() -> tuple[bool, str]:\\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\\n+ return False, f\\\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+ if sys.platform != \\\"win32\\\":\\n+ return False, \\\"WaveTone real-backend tests require Windows\\\"\\n+ if not (os.environ.get(\\\"WAVETONE_EXE\\\") or os.environ.get(\\\"WAVETONE_HOME\\\")):\\n+ return False, \\\"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\\\"\\n+\\n+ status = wavetone_backend.doctor()\\n+ if status.get(\\\"ready\\\"):\\n+ return True, \\\"\\\"\\n+\\n+ failed_checks = [check[\\\"name\\\"] for check in status.get(\\\"checks\\\", []) if not check.get(\\\"ok\\\")]\\n+ reason = \\\", \\\".join(failed_checks) if failed_checks else \\\"WaveTone backend is not ready\\\"\\n+ return False, f\\\"WaveTone real backend unavailable: {reason}\\\"\\n+\\n+\\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\\n+\\n+\\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_EXE\\\", raising=False)\\n+ monkeypatch.delenv(\\\"WAVETONE_HOME\\\", raising=False)\\n+\\n+ ready, reason = _real_backend_ready()\\n+\\n+ assert ready is False\\n+ assert REAL_BACKEND_ENV in reason\\n+\\n+\\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setenv(\\\"CLI_ANYTHING_FORCE_INSTALLED\\\", \\\"1\\\")\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: pytest.fail(\\\"default resolver should not inspect PATH\\\"))\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\") == [sys.executable, \\\"-m\\\", \\\"cli_anything.wavetone.wavetone_cli\\\"]\\n+\\n+\\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\\n+ monkeypatch.setattr(shutil, \\\"which\\\", lambda name: \\\"C:/installed/cli-anything-wavetone.exe\\\")\\n+\\n+ assert _resolve_cli(\\\"cli-anything-wavetone\\\", force_installed=True) == [\\\"C:/installed/cli-anything-wavetone.exe\\\"]\\n+\\n+\\n+class TestCLISubprocess:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_help(self) -> None:\\n+ result = self._run([\\\"--help\\\"])\\n+ assert \\\"Agent-native CLI harness for WaveTone\\\" in result.stdout\\n+\\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\\n+ wav = make_wav(tmp_path / \\\"tone.wav\\\")\\n+ project = tmp_path / \\\"tone.wt.json\\\"\\n+\\n+ result = self._run([\\\"--json\\\", \\\"project\\\", \\\"new\\\", str(wav), \\\"-o\\\", str(project)])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ok\\\"] is True\\n+ assert project.exists()\\n+\\n+ result = self._run(\\n+ [\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"set-tempo\\\", \\\"--bpm\\\", \\\"132.5\\\", \\\"--first-bar\\\", \\\"0.1\\\"]\\n+ )\\n+ assert json.loads(result.stdout)[\\\"tempo\\\"][\\\"bpm\\\"] == 132.5\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"project\\\", \\\"add-label\\\", \\\"intro\\\", \\\"--time\\\", \\\"0.25\\\"])\\n+ assert json.loads(result.stdout)[\\\"labels\\\"][0][\\\"name\\\"] == \\\"intro\\\"\\n+\\n+ result = self._run([\\\"--project\\\", str(project), \\\"--json\\\", \\\"audio\\\", \\\"probe\\\"])\\n+ audio = json.loads(result.stdout)[\\\"audio\\\"]\\n+ assert audio[\\\"duration_seconds\\\"] == 0.5\\n+ assert audio[\\\"channels\\\"] == 1\\n+ print(f\\\"\\\\n Project: {project}\\\")\\n+ print(f\\\" Audio: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n+\\n+ def test_formats_json(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"formats\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert \\\".wav\\\" in data[\\\"formats\\\"][\\\"extensions\\\"]\\n+ assert \\\"MP3\\\" in data[\\\"formats\\\"][\\\"from_readme\\\"]\\n+\\n+\\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\\n+class TestRealWaveToneBackend:\\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\\n+ return subprocess.run(_resolve_cli(\\\"cli-anything-wavetone\\\") + args, capture_output=True, text=True, check=check)\\n+\\n+ def test_doctor_real_backend(self) -> None:\\n+ result = self._run([\\\"--json\\\", \\\"wavetone\\\", \\\"doctor\\\"])\\n+ data = json.loads(result.stdout)\\n+ assert data[\\\"ready\\\"] is True\\n+ assert any(check[\\\"name\\\"] == \\\"data/asdecoder.exe\\\" and check[\\\"ok\\\"] for check in data[\\\"checks\\\"])\\n+ print(f\\\"\\\\n WaveTone root: {data['root']}\\\")\\n+\\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\\n+ exe = wavetone_backend.find_wavetone()\\n+ wav = make_wav(tmp_path / \\\"launch.wav\\\")\\n+ result = self._run(\\n+ [\\n+ \\\"--json\\\",\\n+ \\\"wavetone\\\",\\n+ \\\"launch\\\",\\n+ str(wav),\\n+ \\\"--exe\\\",\\n+ str(exe),\\n+ \\\"--wait\\\",\\n+ \\\"1\\\",\\n+ \\\"--terminate\\\",\\n+ ]\\n+ )\\n+ data = json.loads(result.stdout)[\\\"launch\\\"]\\n+ assert data[\\\"backend\\\"] == \\\"wavetone.exe\\\"\\n+ assert data[\\\"audio_path\\\"] == str(wav.resolve())\\n+ assert data[\\\"running_after_wait\\\"] is True\\n+ assert data[\\\"terminated\\\"] is True\\n+ print(f\\\"\\\\n Launched WaveTone PID: {data['pid']}\\\")\\n+ print(f\\\" WAV: {wav} ({wav.stat().st_size:,} bytes)\\\")\\n\"\n },\n {\n \"comment\": \"`attach-wfd` is described as attaching a WaveTone-saved WFD file, but the `wfd_path` argument does not require the file to exist (`exists=True` is missing). This allows persisting manifests with invalid/nonexistent WFD paths without any immediate feedback. If the intent is to attach an actual saved WFD, make `wfd_path` validate existence (and optionally validate the `.wfd` suffix) to catch mistakes early.\",\n \"path\": \"wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\",\n \"hunk\": \"@@ -0,0 +1,369 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\",\n \"resolving_sha\": \"f5b2212c84cb3490fa96735f33c05e9601f6cf8b\",\n \"resolving_diff\": \"diff --git a/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\nnew file mode 100644\\nindex 000000000..2df5646f0\\n--- /dev/null\\n+++ b/wavetone/agent-harness/cli_anything/wavetone/wavetone_cli.py\\n@@ -0,0 +1,371 @@\\n+\\\"\\\"\\\"Click CLI for WaveTone 2.61.\\\"\\\"\\\"\\n+\\n+from __future__ import annotations\\n+\\n+import json\\n+import shlex\\n+from pathlib import Path\\n+from typing import Any\\n+\\n+import click\\n+\\n+from cli_anything.wavetone import __version__\\n+from cli_anything.wavetone.core.audio import probe_audio\\n+from cli_anything.wavetone.core.project import (\\n+ DEFAULT_ANALYSIS_SETTINGS,\\n+ add_label,\\n+ create_project,\\n+ load_project,\\n+ project_summary,\\n+ save_project,\\n+ set_tempo,\\n+ set_wfd_path,\\n+ update_analysis,\\n+)\\n+from cli_anything.wavetone.core.session import append_event, load_events\\n+from cli_anything.wavetone.utils import wavetone_backend\\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\\n+\\n+\\n+def emit(data: dict[str, Any], json_mode: bool) -> None:\\n+ if json_mode:\\n+ click.echo(json.dumps(data, indent=2, sort_keys=True))\\n+ return\\n+ for key, value in data.items():\\n+ if isinstance(value, (dict, list)):\\n+ click.echo(f\\\"{key}: {json.dumps(value, sort_keys=True)}\\\")\\n+ else:\\n+ click.echo(f\\\"{key}: {value}\\\")\\n+\\n+\\n+def ctx_json(ctx: click.Context) -> bool:\\n+ return bool(ctx.obj and ctx.obj.get(\\\"json\\\"))\\n+\\n+\\n+def ctx_project(ctx: click.Context) -> Path | None:\\n+ value = ctx.obj.get(\\\"project\\\") if ctx.obj else None\\n+ return Path(value).expanduser().resolve() if value else None\\n+\\n+\\n+def load_ctx_project(ctx: click.Context, explicit_path: str | Path | None = None) -> tuple[dict[str, Any], Path]:\\n+ path = Path(explicit_path).expanduser().resolve() if explicit_path else ctx_project(ctx)\\n+ if not path:\\n+ raise click.ClickException(\\\"Project path required. Use --project PATH or pass a project argument.\\\")\\n+ return load_project(path), path\\n+\\n+\\n+def _strip_matching_quotes(value: str) -> str:\\n+ if len(value) >= 2 and value[0] == value[-1] and value[0] in {\\\"'\\\", '\\\"'}:\\n+ return value[1:-1]\\n+ return value\\n+\\n+\\n+def _split_repl_args(line: str) -> list[str]:\\n+ return [_strip_matching_quotes(arg) for arg in shlex.split(line, posix=False)]\\n+\\n+\\n+@click.group(invoke_without_command=True)\\n+@click.option(\\\"--project\\\", \\\"project_path\\\", type=click.Path(dir_okay=False), help=\\\"WaveTone project JSON path.\\\")\\n+@click.option(\\\"--json\\\", \\\"json_mode\\\", is_flag=True, help=\\\"Emit machine-readable JSON.\\\")\\n+@click.version_option(version=__version__, prog_name=\\\"cli-anything-wavetone\\\")\\n+@click.pass_context\\n+def cli(ctx: click.Context, project_path: str | None, json_mode: bool) -> None:\\n+ \\\"\\\"\\\"Agent-native CLI harness for WaveTone 2.61.\\\"\\\"\\\"\\n+ ctx.ensure_object(dict)\\n+ if project_path is not None:\\n+ ctx.obj[\\\"project\\\"] = project_path\\n+ else:\\n+ ctx.obj.setdefault(\\\"project\\\", None)\\n+ if json_mode:\\n+ ctx.obj[\\\"json\\\"] = True\\n+ else:\\n+ ctx.obj.setdefault(\\\"json\\\", False)\\n+ if ctx.invoked_subcommand is None:\\n+ ctx.invoke(repl)\\n+\\n+\\n+@cli.command()\\n+@click.pass_context\\n+def repl(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Start an interactive command loop.\\\"\\\"\\\"\\n+ skin = ReplSkin(\\\"WaveTone\\\", version=__version__)\\n+ skin.print_banner()\\n+ skin.info(\\\"Type 'help' for commands, 'exit' to quit.\\\")\\n+ prompt_session = skin.create_prompt_session()\\n+ while True:\\n+ try:\\n+ line = skin.get_input(prompt_session, project_name=\\\"wavetone\\\", modified=False)\\n+ except (EOFError, KeyboardInterrupt):\\n+ break\\n+ line = line.strip()\\n+ if not line:\\n+ continue\\n+ if line in {\\\"exit\\\", \\\"quit\\\"}:\\n+ break\\n+ if line == \\\"help\\\":\\n+ click.echo(cli.get_help(ctx))\\n+ continue\\n+ try:\\n+ args = _split_repl_args(line)\\n+ cli.main(args=args, prog_name=\\\"cli-anything-wavetone\\\", standalone_mode=False, obj=ctx.obj)\\n+ except click.ClickException as exc: # pragma: no cover\\n+ skin.error(exc.format_message())\\n+ except click.exceptions.Exit as exc: # pragma: no cover\\n+ if exc.exit_code not in (0, None):\\n+ skin.error(f\\\"Command exited with code {exc.exit_code}\\\")\\n+ except Exception as exc: # pragma: no cover\\n+ skin.error(f\\\"Unexpected error: {exc}\\\")\\n+ skin.print_goodbye()\\n+\\n+\\n+@cli.group(name=\\\"project\\\")\\n+def project_group() -> None:\\n+ \\\"\\\"\\\"Create and edit WaveTone project manifests.\\\"\\\"\\\"\\n+\\n+\\n+@project_group.command(\\\"new\\\")\\n+@click.argument(\\\"audio_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"-o\\\", \\\"--output\\\", \\\"output_path\\\", type=click.Path(dir_okay=False), required=True)\\n+@click.option(\\\"--name\\\", help=\\\"Project name. Defaults to the audio file stem.\\\")\\n+@click.pass_context\\n+def project_new(ctx: click.Context, audio_path: str, output_path: str, name: str | None) -> None:\\n+ \\\"\\\"\\\"Create a WaveTone project manifest for an audio file.\\\"\\\"\\\"\\n+ try:\\n+ project = create_project(audio_path, name=name)\\n+ path = save_project(project, output_path)\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"info\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_info(ctx: click.Context, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Inspect a WaveTone project manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"project\\\": project_summary(project)}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"add-label\\\")\\n+@click.argument(\\\"name\\\")\\n+@click.option(\\\"--time\\\", \\\"time_seconds\\\", type=float, required=True, help=\\\"Label time in seconds.\\\")\\n+@click.option(\\\"--note\\\", help=\\\"Optional label note.\\\")\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_add_label(ctx: click.Context, name: str, time_seconds: float, note: str | None, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Add a navigation label to the manifest.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ add_label(project, name=name, time_seconds=time_seconds, note=note)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"labels\\\": project.get(\\\"labels\\\", [])}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"set-tempo\\\")\\n+@click.option(\\\"--bpm\\\", type=float, required=True)\\n+@click.option(\\\"--first-bar\\\", \\\"first_bar_time_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--meter\\\", default=\\\"4/4\\\", show_default=True)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_set_tempo(ctx: click.Context, bpm: float, first_bar_time_seconds: float, meter: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Set the tempo plan WaveTone should use before chord or note work.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_tempo(project, bpm=bpm, first_bar_time_seconds=first_bar_time_seconds, meter=meter)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"tempo\\\": project.get(\\\"tempo\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"analysis\\\")\\n+@click.option(\\\"--blocks-per-second\\\", type=int)\\n+@click.option(\\\"--blocks-per-semitone\\\", type=int)\\n+@click.option(\\\"--note-range\\\")\\n+@click.option(\\\"--reference-frequency-hz\\\", type=float)\\n+@click.option(\\\"--channel\\\", type=click.Choice([\\\"Stereo\\\", \\\"L-R\\\", \\\"L+R\\\", \\\"L\\\", \\\"R\\\"]))\\n+@click.option(\\\"--fundamental\\\", \\\"fundamental\\\", flag_value=True, default=None)\\n+@click.option(\\\"--no-fundamental\\\", \\\"fundamental\\\", flag_value=False, default=None)\\n+@click.option(\\\"--skip-dialog\\\", \\\"skip_dialog\\\", flag_value=True, default=None)\\n+@click.option(\\\"--show-dialog\\\", \\\"skip_dialog\\\", flag_value=False, default=None)\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_analysis(\\n+ ctx: click.Context,\\n+ blocks_per_second: int | None,\\n+ blocks_per_semitone: int | None,\\n+ note_range: str | None,\\n+ reference_frequency_hz: float | None,\\n+ channel: str | None,\\n+ fundamental: bool | None,\\n+ skip_dialog: bool | None,\\n+ project_path: str | None,\\n+) -> None:\\n+ \\\"\\\"\\\"Update intended WaveTone analysis settings.\\\"\\\"\\\"\\n+ try:\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ update_analysis(\\n+ project,\\n+ blocks_per_second=blocks_per_second,\\n+ blocks_per_semitone=blocks_per_semitone,\\n+ note_range=note_range,\\n+ reference_frequency_hz=reference_frequency_hz,\\n+ channel=channel,\\n+ analyze_fundamental_frequency=fundamental,\\n+ skip_analysis_dialog=skip_dialog,\\n+ )\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"analysis\\\": project.get(\\\"analysis\\\")}, ctx_json(ctx))\\n+\\n+\\n+@project_group.command(\\\"attach-wfd\\\")\\n+@click.argument(\\\"wfd_path\\\", type=click.Path(exists=True, dir_okay=False))\\n+@click.argument(\\\"project_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def project_attach_wfd(ctx: click.Context, wfd_path: str, project_path: str | None) -> None:\\n+ \\\"\\\"\\\"Attach a WFD analysis file saved by WaveTone.\\\"\\\"\\\"\\n+ try:\\n+ if Path(wfd_path).suffix.lower() != \\\".wfd\\\":\\n+ raise ValueError(\\\"WFD path must use the .wfd extension\\\")\\n+ project, path = load_ctx_project(ctx, project_path)\\n+ set_wfd_path(project, wfd_path)\\n+ save_project(project, path)\\n+ except (OSError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"project_path\\\": str(path), \\\"wfd_path\\\": project.get(\\\"wfd_path\\\")}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"audio\\\")\\n+def audio_group() -> None:\\n+ \\\"\\\"\\\"Probe audio files before opening them in WaveTone.\\\"\\\"\\\"\\n+\\n+\\n+@audio_group.command(\\\"probe\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.pass_context\\n+def audio_probe(ctx: click.Context, audio_path: str | None) -> None:\\n+ \\\"\\\"\\\"Return duration, sample rate, channel, codec, and size metadata.\\\"\\\"\\\"\\n+ try:\\n+ if audio_path:\\n+ target = audio_path\\n+ else:\\n+ project, _ = load_ctx_project(ctx)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = probe_audio(target)\\n+ except (OSError, ValueError, RuntimeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"audio\\\": data}, ctx_json(ctx))\\n+\\n+\\n+@cli.group(name=\\\"wavetone\\\")\\n+def wavetone_group() -> None:\\n+ \\\"\\\"\\\"Inspect and launch the real WaveTone executable.\\\"\\\"\\\"\\n+\\n+\\n+@wavetone_group.command(\\\"doctor\\\")\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.pass_context\\n+def wavetone_doctor(ctx: click.Context, executable: str | None) -> None:\\n+ \\\"\\\"\\\"Check whether WaveTone and its bundled decoder files are available.\\\"\\\"\\\"\\n+ data = wavetone_backend.doctor(executable)\\n+ emit(data, ctx_json(ctx))\\n+ if not data.get(\\\"ready\\\"):\\n+ raise click.exceptions.Exit(1)\\n+\\n+\\n+@wavetone_group.command(\\\"formats\\\")\\n+@click.pass_context\\n+def wavetone_formats(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"List audio formats documented by WaveTone 2.61.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"formats\\\": wavetone_backend.supported_formats()}, ctx_json(ctx))\\n+\\n+\\n+@wavetone_group.command(\\\"launch\\\")\\n+@click.argument(\\\"audio_path\\\", required=False, type=click.Path(exists=True, dir_okay=False))\\n+@click.option(\\\"--exe\\\", \\\"executable\\\", type=click.Path(dir_okay=False), help=\\\"Path to wavetone.exe.\\\")\\n+@click.option(\\\"--wait\\\", \\\"wait_seconds\\\", type=float, default=0.0, show_default=True)\\n+@click.option(\\\"--terminate\\\", is_flag=True, help=\\\"Terminate after the wait period, useful for smoke tests.\\\")\\n+@click.pass_context\\n+def wavetone_launch(ctx: click.Context, audio_path: str | None, executable: str | None, wait_seconds: float, terminate: bool) -> None:\\n+ \\\"\\\"\\\"Launch the real WaveTone GUI, optionally with an audio file.\\\"\\\"\\\"\\n+ try:\\n+ target = audio_path\\n+ if not target:\\n+ project_path = ctx_project(ctx)\\n+ if project_path:\\n+ project = load_project(project_path)\\n+ target = project[\\\"audio\\\"][\\\"path\\\"]\\n+ data = wavetone_backend.launch_wavetone(\\n+ audio_path=target,\\n+ executable=executable,\\n+ wait_seconds=wait_seconds,\\n+ terminate=terminate,\\n+ )\\n+ except (OSError, RuntimeError, ValueError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ failed_launch = (\\n+ wait_seconds > 0\\n+ and not data.get(\\\"running_after_wait\\\")\\n+ and not data.get(\\\"terminated\\\")\\n+ and data.get(\\\"exit_code\\\") not in (None, 0)\\n+ )\\n+ emit({\\\"ok\\\": not failed_launch, \\\"launch\\\": data}, ctx_json(ctx))\\n+ if failed_launch:\\n+ raise click.exceptions.Exit(int(data.get(\\\"exit_code\\\") or 1))\\n+\\n+\\n+@cli.group(name=\\\"session\\\")\\n+def session_group() -> None:\\n+ \\\"\\\"\\\"Record lightweight CLI session events.\\\"\\\"\\\"\\n+\\n+\\n+@session_group.command(\\\"record\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.argument(\\\"event\\\")\\n+@click.option(\\\"--payload\\\", default=\\\"{}\\\", help=\\\"JSON object payload.\\\")\\n+@click.pass_context\\n+def session_record(ctx: click.Context, session_path: str, event: str, payload: str) -> None:\\n+ \\\"\\\"\\\"Append an event to a session log.\\\"\\\"\\\"\\n+ try:\\n+ payload_data = json.loads(payload)\\n+ if not isinstance(payload_data, dict):\\n+ raise ValueError(\\\"Payload must be a JSON object\\\")\\n+ record = append_event(session_path, event, payload_data)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"event\\\": record}, ctx_json(ctx))\\n+\\n+\\n+@session_group.command(\\\"events\\\")\\n+@click.argument(\\\"session_path\\\", type=click.Path(dir_okay=False))\\n+@click.pass_context\\n+def session_events(ctx: click.Context, session_path: str) -> None:\\n+ \\\"\\\"\\\"List session events.\\\"\\\"\\\"\\n+ try:\\n+ events = load_events(session_path)\\n+ except (OSError, ValueError, json.JSONDecodeError) as exc:\\n+ raise click.ClickException(str(exc)) from exc\\n+ emit({\\\"ok\\\": True, \\\"events\\\": events}, ctx_json(ctx))\\n+\\n+\\n+@cli.command(\\\"defaults\\\")\\n+@click.pass_context\\n+def defaults(ctx: click.Context) -> None:\\n+ \\\"\\\"\\\"Show default WaveTone analysis settings used in new manifests.\\\"\\\"\\\"\\n+ emit({\\\"ok\\\": True, \\\"analysis_defaults\\\": DEFAULT_ANALYSIS_SETTINGS}, ctx_json(ctx))\\n+\\n+\\n+def main() -> None:\\n+ cli(obj={})\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":"diff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/TEST.md b/wavetone/agent-harness/cli_anything/wavetone/tests/TEST.md\nnew file mode 100644\nindex 000000000..863aa6bc5\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/TEST.md\n@@ -0,0 +1,177 @@\n+# WaveTone Harness Test Plan and Results\n+\n+## Test Inventory Plan\n+\n+- `test_core.py`: 24 unit tests for project manifests, audio probing, session logs,\n+ and backend discovery.\n+- `test_full_e2e.py`: 8 tests covering default real-backend opt-in gating,\n+ source-module subprocess resolution, CLI workflows, and real WaveTone launch\n+ smoke coverage.\n+\n+## Unit Test Plan\n+\n+- Create a manifest from a supported WAV file.\n+- Reject missing files and unsupported extensions.\n+- Save and load schema-compatible JSON.\n+- Reject non-object project JSON.\n+- Add labels in sorted time order.\n+- Set tempo and analysis options.\n+- Preserve omitted CLI boolean analysis flags as tri-state values.\n+- Require attached WFD analysis files to exist and use the `.wfd` suffix.\n+- Reject non-finite numeric project values before JSON serialization.\n+- Probe a generated WAV file with the Python stdlib.\n+- Fall back to stat metadata for malformed WAV files.\n+- Probe non-WAV audio with a single stable `ffprobe -show_entries` argument.\n+- Safely parse non-numeric ffprobe metadata.\n+- Append and reload session events.\n+- Reject invalid session JSON schemas with clear `ValueError`s.\n+- Reject non-finite session payload values before writing JSON.\n+- Resolve `WAVETONE_EXE` from the environment.\n+- Reject WaveTone backend data artifacts that are directories instead of files.\n+- Preserve inherited project and JSON context for REPL-style nested CLI\n+ invocations.\n+- Return a failing exit status for launch smoke checks when the backend exits\n+ early with a nonzero code.\n+- Convert launch runtime errors to clean CLI errors.\n+- Reject GUI launch attempts on non-Windows hosts with a clear error.\n+- Strip Windows REPL path quotes while preserving backslashes.\n+- Preserve WaveTone branding and expose the local skill path in the REPL banner.\n+- Report Click REPL exit control flow without falling through to the unexpected\n+ exception handler.\n+\n+## E2E Test Plan\n+\n+### CLI Project Workflow\n+\n+Simulates an agent preparing an audio file before opening it in WaveTone.\n+\n+Operations:\n+\n+1. Generate a real WAV fixture.\n+2. Resolve the in-tree `python -m cli_anything.wavetone.wavetone_cli` module by\n+ default, even if an installed `cli-anything-wavetone` exists in `PATH` or\n+ `CLI_ANYTHING_FORCE_INSTALLED` is set externally.\n+3. Run `cli-anything-wavetone --json project new`.\n+4. Run `project set-tempo`.\n+5. Run `project add-label`.\n+6. Run `audio probe`.\n+\n+Verified:\n+\n+- CLI JSON is parseable.\n+- Project file exists.\n+- Labels and tempo persist.\n+- Audio metadata is correct.\n+\n+### CLI Backend Workflow\n+\n+Simulates an agent validating the installed WaveTone backend. These tests are\n+skipped by default and require `CLI_ANYTHING_WAVETONE_REAL_BACKEND=1` plus\n+`WAVETONE_EXE` or `WAVETONE_HOME`.\n+\n+Operations:\n+\n+1. Run `wavetone doctor`.\n+2. Run `wavetone formats`.\n+3. Launch the real `wavetone.exe` with a generated WAV and terminate it after a\n+ short wait.\n+\n+Verified:\n+\n+- Doctor reports all bundled files.\n+- Formats include documented WaveTone audio extensions.\n+- Real WaveTone process starts and is terminated by the smoke test.\n+\n+## Test Results\n+\n+Default command:\n+\n+```bash\n+$env:PATH = \"$env:APPDATA\\Python\\Python313\\Scripts;$env:PATH\"\n+$env:CLI_ANYTHING_FORCE_INSTALLED = \"1\"\n+Remove-Item Env:CLI_ANYTHING_WAVETONE_REAL_BACKEND -ErrorAction SilentlyContinue\n+Remove-Item Env:WAVETONE_EXE -ErrorAction SilentlyContinue\n+Remove-Item Env:WAVETONE_HOME -ErrorAction SilentlyContinue\n+python -m pytest cli_anything\\wavetone\\tests\\ -v -s\n+```\n+\n+Default result:\n+\n+```text\n+collected 32 items\n+\n+cli_anything/wavetone/tests/test_core.py::test_create_project_manifest PASSED\n+cli_anything/wavetone/tests/test_core.py::test_rejects_unsupported_audio PASSED\n+cli_anything/wavetone/tests/test_core.py::test_save_load_project_roundtrip PASSED\n+cli_anything/wavetone/tests/test_core.py::test_labels_are_sorted PASSED\n+cli_anything/wavetone/tests/test_core.py::test_update_analysis_settings PASSED\n+cli_anything/wavetone/tests/test_core.py::test_cli_analysis_preserves_omitted_boolean_flags PASSED\n+cli_anything/wavetone/tests/test_core.py::test_cli_attach_wfd_requires_existing_wfd_file PASSED\n+cli_anything/wavetone/tests/test_core.py::test_rejects_non_finite_project_numbers PASSED\n+cli_anything/wavetone/tests/test_core.py::test_load_project_rejects_non_object_json PASSED\n+cli_anything/wavetone/tests/test_core.py::test_probe_wav_metadata PASSED\n+cli_anything/wavetone/tests/test_core.py::test_probe_malformed_wav_falls_back_to_stat PASSED\n+cli_anything/wavetone/tests/test_core.py::test_ffprobe_uses_single_show_entries_argument PASSED\n+cli_anything/wavetone/tests/test_core.py::test_ffprobe_handles_non_numeric_metadata PASSED\n+cli_anything/wavetone/tests/test_core.py::test_session_event_log PASSED\n+cli_anything/wavetone/tests/test_core.py::test_session_rejects_invalid_schema PASSED\n+cli_anything/wavetone/tests/test_core.py::test_find_wavetone_from_env PASSED\n+cli_anything/wavetone/tests/test_core.py::test_doctor_rejects_required_data_directories PASSED\n+cli_anything/wavetone/tests/test_core.py::test_cli_preserves_inherited_project_and_json_context PASSED\n+cli_anything/wavetone/tests/test_core.py::test_wavetone_launch_fails_on_early_nonzero_exit PASSED\n+cli_anything/wavetone/tests/test_core.py::test_wavetone_launch_reports_runtime_errors PASSED\n+cli_anything/wavetone/tests/test_core.py::test_launch_requires_windows PASSED\n+cli_anything/wavetone/tests/test_core.py::test_repl_split_strips_windows_quotes PASSED\n+cli_anything/wavetone/tests/test_core.py::test_repl_skin_uses_wavetone_branding_and_local_skill_path PASSED\n+cli_anything/wavetone/tests/test_core.py::test_repl_reports_click_exit_without_unexpected_error PASSED\n+cli_anything/wavetone/tests/test_full_e2e.py::test_real_backend_requires_explicit_opt_in PASSED\n+cli_anything/wavetone/tests/test_full_e2e.py::test_resolve_cli_defaults_to_source_module PASSED\n+cli_anything/wavetone/tests/test_full_e2e.py::test_resolve_cli_uses_installed_only_when_requested PASSED\n+cli_anything/wavetone/tests/test_full_e2e.py::TestCLISubprocess::test_help PASSED\n+cli_anything/wavetone/tests/test_full_e2e.py::TestCLISubprocess::test_project_audio_workflow_json PASSED\n+cli_anything/wavetone/tests/test_full_e2e.py::TestCLISubprocess::test_formats_json PASSED\n+cli_anything/wavetone/tests/test_full_e2e.py::TestRealWaveToneBackend::test_doctor_real_backend SKIPPED\n+cli_anything/wavetone/tests/test_full_e2e.py::TestRealWaveToneBackend::test_launch_real_backend_with_wav SKIPPED\n+\n+30 passed, 2 skipped in 1.44s\n+```\n+\n+Real backend opt-in command:\n+\n+```bash\n+$env:PATH = \"$env:APPDATA\\Python\\Python313\\Scripts;$env:PATH\"\n+$env:CLI_ANYTHING_FORCE_INSTALLED = \"1\"\n+$env:CLI_ANYTHING_WAVETONE_REAL_BACKEND = \"1\"\n+$env:WAVETONE_HOME = \"C:\\Users\\Hp\\Desktop\\wavetone2.6.1\"\n+Remove-Item Env:WAVETONE_EXE -ErrorAction SilentlyContinue\n+python -m pytest cli_anything\\wavetone\\tests\\ -v -s\n+```\n+\n+Real backend result:\n+\n+```text\n+32 passed in 3.03s\n+```\n+\n+## Coverage Notes\n+\n+- Unit tests cover manifest creation, validation, persistence, labels, tempo,\n+ analysis settings, CLI analysis flag tri-state behavior, finite numeric\n+ validation, WFD attachment validation, project JSON schema validation, audio\n+ probing, malformed WAV fallback, session logs, session schema and payload\n+ validation, backend discovery, backend data artifact validation, ffprobe\n+ argument construction, ffprobe metadata parsing, inherited CLI project and\n+ JSON context, failed launch smoke reporting, launch runtime error reporting,\n+ Windows launch gating, REPL Windows path splitting, REPL branding and local\n+ skill path display, and REPL Click exit handling.\n+- CLI subprocess tests resolve and use the in-tree\n+ `python -m cli_anything.wavetone.wavetone_cli` module by default, regardless\n+ of ambient `CLI_ANYTHING_FORCE_INSTALLED`.\n+- Real backend coverage launches `C:\\Users\\Hp\\Desktop\\wavetone2.6.1\\wavetone.exe`\n+ with a generated WAV and terminates it after a short wait.\n+- Real backend tests are skipped by default unless\n+ `CLI_ANYTHING_WAVETONE_REAL_BACKEND=1` and `WAVETONE_EXE` or `WAVETONE_HOME`\n+ are set.\n+- WaveTone 2.61 has no documented headless analysis/export API. Export\n+ verification remains a known gap until a stable non-GUI automation surface is\n+ discovered.\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/__init__.py b/wavetone/agent-harness/cli_anything/wavetone/tests/__init__.py\nnew file mode 100644\nindex 000000000..8a3970792\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/__init__.py\n@@ -0,0 +1,1 @@\n+\"\"\"Tests for cli-anything-wavetone.\"\"\"\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/helpers.py b/wavetone/agent-harness/cli_anything/wavetone/tests/helpers.py\nnew file mode 100644\nindex 000000000..a64fbee83\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/helpers.py\n@@ -0,0 +1,18 @@\n+from __future__ import annotations\n+\n+import math\n+import struct\n+import wave\n+from pathlib import Path\n+\n+\n+def make_wav(path: Path, freq: float = 440.0, duration: float = 0.5, sample_rate: int = 8000) -> Path:\n+ frames = int(duration * sample_rate)\n+ with wave.open(str(path), \"wb\") as handle:\n+ handle.setnchannels(1)\n+ handle.setsampwidth(2)\n+ handle.setframerate(sample_rate)\n+ for idx in range(frames):\n+ sample = int(16000 * math.sin(2 * math.pi * freq * idx / sample_rate))\n+ handle.writeframes(struct.pack(\"<h\", sample))\n+ return path\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_core.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_core.py\nnew file mode 100644\nindex 000000000..4472cf8ab\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_core.py\n@@ -0,0 +1,422 @@\n+from __future__ import annotations\n+\n+import json\n+import subprocess\n+from pathlib import Path\n+\n+import click\n+import pytest\n+from click.testing import CliRunner\n+\n+from cli_anything.wavetone import wavetone_cli as cli_module\n+from cli_anything.wavetone.core import audio as audio_core\n+from cli_anything.wavetone.core.audio import probe_audio\n+from cli_anything.wavetone.core.project import (\n+ DEFAULT_ANALYSIS_SETTINGS,\n+ add_label,\n+ create_project,\n+ load_project,\n+ save_project,\n+ set_tempo,\n+ update_analysis,\n+)\n+from cli_anything.wavetone.core.session import append_event, load_events\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+from cli_anything.wavetone.utils.repl_skin import ReplSkin\n+from cli_anything.wavetone.wavetone_cli import _split_repl_args, cli\n+\n+\n+def test_create_project_manifest(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = create_project(wav, name=\"Tone Test\")\n+\n+ assert project[\"schema_version\"] == \"wavetone-project/v1\"\n+ assert project[\"project\"][\"name\"] == \"Tone Test\"\n+ assert project[\"audio\"][\"path\"] == str(wav.resolve())\n+ assert project[\"analysis\"] == DEFAULT_ANALYSIS_SETTINGS\n+\n+\n+def test_rejects_unsupported_audio(tmp_path: Path) -> None:\n+ txt = tmp_path / \"not-audio.txt\"\n+ txt.write_text(\"x\", encoding=\"utf-8\")\n+\n+ with pytest.raises(ValueError):\n+ create_project(txt)\n+\n+\n+def test_save_load_project_roundtrip(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = create_project(wav)\n+ add_label(project, \"chorus\", 12.5)\n+ set_tempo(project, 128, first_bar_time_seconds=0.2)\n+ output = save_project(project, tmp_path / \"project.json\")\n+\n+ loaded = load_project(output)\n+ assert loaded[\"labels\"][0][\"name\"] == \"chorus\"\n+ assert loaded[\"tempo\"][\"bpm\"] == 128\n+ assert loaded[\"tempo\"][\"first_bar_time_seconds\"] == 0.2\n+\n+\n+def test_labels_are_sorted(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = create_project(wav)\n+ add_label(project, \"late\", 4.0)\n+ add_label(project, \"early\", 1.0)\n+ add_label(project, \"middle\", \"2.5\")\n+\n+ assert [label[\"name\"] for label in project[\"labels\"]] == [\"early\", \"middle\", \"late\"]\n+\n+\n+def test_update_analysis_settings(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = create_project(wav)\n+ update_analysis(project, channel=\"L+R\", blocks_per_second=24, analyze_fundamental_frequency=False)\n+\n+ assert project[\"analysis\"][\"channel\"] == \"L+R\"\n+ assert project[\"analysis\"][\"blocks_per_second\"] == 24\n+ assert project[\"analysis\"][\"analyze_fundamental_frequency\"] is False\n+\n+\n+def test_cli_analysis_preserves_omitted_boolean_flags(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = create_project(wav)\n+ project[\"analysis\"][\"analyze_fundamental_frequency\"] = True\n+ project[\"analysis\"][\"skip_analysis_dialog\"] = True\n+ project_path = save_project(project, tmp_path / \"tone.wt.json\")\n+\n+ result = CliRunner().invoke(cli, [\"--json\", \"project\", \"analysis\", \"--channel\", \"R\", str(project_path)])\n+\n+ assert result.exit_code == 0, result.output\n+ data = json.loads(result.output)\n+ assert data[\"analysis\"][\"channel\"] == \"R\"\n+ assert data[\"analysis\"][\"analyze_fundamental_frequency\"] is True\n+ assert data[\"analysis\"][\"skip_analysis_dialog\"] is True\n+\n+ loaded = load_project(project_path)\n+ assert loaded[\"analysis\"][\"channel\"] == \"R\"\n+ assert loaded[\"analysis\"][\"analyze_fundamental_frequency\"] is True\n+ assert loaded[\"analysis\"][\"skip_analysis_dialog\"] is True\n+\n+\n+def test_cli_attach_wfd_requires_existing_wfd_file(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project_path = save_project(create_project(wav), tmp_path / \"tone.wt.json\")\n+\n+ missing = tmp_path / \"missing.wfd\"\n+ result = CliRunner().invoke(cli, [\"--project\", str(project_path), \"project\", \"attach-wfd\", str(missing)])\n+ assert result.exit_code != 0\n+ assert \"does not exist\" in result.output\n+\n+ wrong_suffix = tmp_path / \"analysis.txt\"\n+ wrong_suffix.write_text(\"wfd\", encoding=\"utf-8\")\n+ result = CliRunner().invoke(cli, [\"--project\", str(project_path), \"project\", \"attach-wfd\", str(wrong_suffix)])\n+ assert result.exit_code == 1\n+ assert \".wfd\" in result.output\n+\n+ wfd_path = tmp_path / \"analysis.wfd\"\n+ wfd_path.write_text(\"wfd\", encoding=\"utf-8\")\n+ result = CliRunner().invoke(cli, [\"--project\", str(project_path), \"--json\", \"project\", \"attach-wfd\", str(wfd_path)])\n+\n+ assert result.exit_code == 0, result.output\n+ data = json.loads(result.output)\n+ assert data[\"wfd_path\"] == str(wfd_path.resolve())\n+\n+\n+def test_rejects_non_finite_project_numbers(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = create_project(wav)\n+\n+ with pytest.raises(ValueError, match=\"BPM.*finite\"):\n+ set_tempo(project, float(\"nan\"))\n+\n+ with pytest.raises(ValueError, match=\"reference_frequency_hz.*finite\"):\n+ update_analysis(project, reference_frequency_hz=float(\"inf\"))\n+\n+\n+def test_load_project_rejects_non_object_json(tmp_path: Path) -> None:\n+ project_path = tmp_path / \"broken.wt.json\"\n+ project_path.write_text(\"[]\", encoding=\"utf-8\")\n+\n+ with pytest.raises(ValueError, match=\"JSON object\"):\n+ load_project(project_path)\n+\n+\n+def test_probe_wav_metadata(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\", duration=0.5, sample_rate=16000)\n+ info = probe_audio(wav)\n+\n+ assert info[\"probe_method\"] == \"python-wave\"\n+ assert info[\"sample_rate\"] == 16000\n+ assert info[\"channels\"] == 1\n+ assert info[\"duration_seconds\"] == 0.5\n+ assert info[\"size_bytes\"] > 0\n+\n+\n+def test_probe_malformed_wav_falls_back_to_stat(tmp_path: Path) -> None:\n+ wav = tmp_path / \"broken.wav\"\n+ wav.write_bytes(b\"\")\n+\n+ info = probe_audio(wav)\n+\n+ assert info[\"probe_method\"] == \"stat\"\n+ assert info[\"format\"] == \"wav\"\n+ assert info[\"duration_seconds\"] is None\n+ assert info[\"size_bytes\"] == 0\n+\n+\n+def test_ffprobe_uses_single_show_entries_argument(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:\n+ audio = tmp_path / \"tone.mp3\"\n+ audio.write_bytes(b\"mp3\")\n+ captured: dict[str, list[str]] = {}\n+\n+ monkeypatch.setattr(audio_core.shutil, \"which\", lambda name: \"ffprobe\")\n+\n+ def fake_run(args: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:\n+ captured[\"args\"] = args\n+ stdout = json.dumps(\n+ {\n+ \"streams\": [\n+ {\n+ \"codec_type\": \"audio\",\n+ \"codec_name\": \"mp3\",\n+ \"sample_rate\": \"44100\",\n+ \"channels\": \"2\",\n+ }\n+ ],\n+ \"format\": {\n+ \"duration\": \"1.25\",\n+ \"format_name\": \"mp3\",\n+ \"bit_rate\": \"128000\",\n+ \"size\": \"3\",\n+ },\n+ }\n+ )\n+ return subprocess.CompletedProcess(args, 0, stdout=stdout)\n+\n+ monkeypatch.setattr(audio_core.subprocess, \"run\", fake_run)\n+\n+ info = audio_core._probe_ffprobe(audio)\n+ entries = captured[\"args\"][captured[\"args\"].index(\"-show_entries\") + 1]\n+\n+ assert captured[\"args\"].count(\"-show_entries\") == 1\n+ assert \"stream=codec_type,codec_name,sample_rate,channels\" in entries\n+ assert \":format=duration,format_name,bit_rate,size\" in entries\n+ assert info[\"probe_method\"] == \"ffprobe\"\n+ assert info[\"sample_rate\"] == 44100\n+ assert info[\"channels\"] == 2\n+\n+\n+def test_ffprobe_handles_non_numeric_metadata(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:\n+ audio = tmp_path / \"tone.mp3\"\n+ audio.write_bytes(b\"mp3\")\n+\n+ monkeypatch.setattr(audio_core.shutil, \"which\", lambda name: \"ffprobe\")\n+\n+ def fake_run(args: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:\n+ stdout = json.dumps(\n+ {\n+ \"streams\": [{\"codec_type\": \"audio\", \"sample_rate\": \"N/A\"}],\n+ \"format\": {\n+ \"duration\": \"N/A\",\n+ \"format_name\": \"mp3\",\n+ \"bit_rate\": \"N/A\",\n+ \"size\": \"N/A\",\n+ },\n+ }\n+ )\n+ return subprocess.CompletedProcess(args, 0, stdout=stdout)\n+\n+ monkeypatch.setattr(audio_core.subprocess, \"run\", fake_run)\n+\n+ info = audio_core._probe_ffprobe(audio)\n+\n+ assert info[\"duration_seconds\"] is None\n+ assert info[\"sample_rate\"] is None\n+ assert info[\"bit_rate\"] is None\n+ assert info[\"size_bytes\"] == audio.stat().st_size\n+\n+\n+def test_session_event_log(tmp_path: Path) -> None:\n+ session_path = tmp_path / \"session.json\"\n+ append_event(session_path, \"created\", {\"project\": \"demo\"})\n+ append_event(session_path, \"launched\", {\"pid\": 123})\n+\n+ events = load_events(session_path)\n+ assert [event[\"event\"] for event in events] == [\"created\", \"launched\"]\n+\n+\n+def test_session_rejects_invalid_schema(tmp_path: Path) -> None:\n+ session_path = tmp_path / \"session.json\"\n+ session_path.write_text(\"[]\", encoding=\"utf-8\")\n+\n+ with pytest.raises(ValueError, match=\"JSON object\"):\n+ append_event(session_path, \"created\", {})\n+\n+ session_path.write_text(json.dumps({\"events\": {}}), encoding=\"utf-8\")\n+\n+ with pytest.raises(ValueError, match=\"events.*list\"):\n+ load_events(session_path)\n+\n+ session_path.unlink()\n+\n+ with pytest.raises(ValueError, match=\"finite\"):\n+ append_event(session_path, \"bad\", {\"value\": float(\"nan\")})\n+\n+ assert not session_path.exists()\n+\n+\n+def test_find_wavetone_from_env(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:\n+ fake = tmp_path / \"wavetone.exe\"\n+ fake.write_bytes(b\"MZ\")\n+ monkeypatch.setenv(\"WAVETONE_EXE\", str(fake))\n+\n+ assert wavetone_backend.find_wavetone() == fake.resolve()\n+\n+\n+def test_doctor_rejects_required_data_directories(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:\n+ root = tmp_path / \"wavetone\"\n+ data_dir = root / \"data\"\n+ help_dir = root / \"wthelp\"\n+ data_dir.mkdir(parents=True)\n+ help_dir.mkdir()\n+ exe = root / \"wavetone.exe\"\n+ exe.write_bytes(b\"MZ\")\n+\n+ directory_artifact = wavetone_backend.REQUIRED_DATA_FILES[0]\n+ for filename in wavetone_backend.REQUIRED_DATA_FILES:\n+ path = data_dir / filename\n+ if filename == directory_artifact:\n+ path.mkdir()\n+ else:\n+ path.write_bytes(b\"x\")\n+\n+ monkeypatch.setenv(\"WAVETONE_EXE\", str(exe))\n+ monkeypatch.setattr(wavetone_backend.platform, \"system\", lambda: \"Windows\")\n+ monkeypatch.setattr(wavetone_backend.platform, \"platform\", lambda: \"Windows-test\")\n+\n+ status = wavetone_backend.doctor()\n+ artifact = next(check for check in status[\"checks\"] if check[\"name\"] == f\"data/{directory_artifact}\")\n+\n+ assert status[\"ready\"] is False\n+ assert artifact[\"ok\"] is False\n+\n+\n+def test_cli_preserves_inherited_project_and_json_context(tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project_path = save_project(create_project(wav), tmp_path / \"tone.wt.json\")\n+\n+ result = CliRunner().invoke(\n+ cli,\n+ [\"audio\", \"probe\"],\n+ obj={\"project\": str(project_path), \"json\": True},\n+ )\n+\n+ assert result.exit_code == 0, result.output\n+ data = json.loads(result.output)\n+ assert data[\"audio\"][\"path\"] == str(wav.resolve())\n+\n+\n+def test_wavetone_launch_fails_on_early_nonzero_exit(monkeypatch: pytest.MonkeyPatch) -> None:\n+ def fake_launch_wavetone(**kwargs: object) -> dict[str, object]:\n+ return {\n+ \"backend\": \"wavetone.exe\",\n+ \"executable\": \"C:/fake/wavetone.exe\",\n+ \"running_after_wait\": False,\n+ \"terminated\": False,\n+ \"exit_code\": 42,\n+ }\n+\n+ monkeypatch.setattr(wavetone_backend, \"launch_wavetone\", fake_launch_wavetone)\n+\n+ result = CliRunner().invoke(cli, [\"--json\", \"wavetone\", \"launch\", \"--wait\", \"1\"])\n+\n+ assert result.exit_code == 42\n+ data = json.loads(result.output)\n+ assert data[\"ok\"] is False\n+ assert data[\"launch\"][\"exit_code\"] == 42\n+\n+\n+def test_wavetone_launch_reports_runtime_errors(monkeypatch: pytest.MonkeyPatch) -> None:\n+ def fake_launch_wavetone(**kwargs: object) -> dict[str, object]:\n+ raise RuntimeError(\"WaveTone launch requires Windows\")\n+\n+ monkeypatch.setattr(wavetone_backend, \"launch_wavetone\", fake_launch_wavetone)\n+\n+ result = CliRunner().invoke(cli, [\"--json\", \"wavetone\", \"launch\"])\n+\n+ assert result.exit_code == 1\n+ assert \"WaveTone launch requires Windows\" in result.output\n+ assert \"Traceback\" not in result.output\n+\n+\n+def test_launch_requires_windows(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setattr(wavetone_backend.platform, \"system\", lambda: \"Linux\")\n+\n+ with pytest.raises(RuntimeError, match=\"requires Windows\"):\n+ wavetone_backend.launch_wavetone()\n+\n+\n+def test_repl_split_strips_windows_quotes() -> None:\n+ line = 'project new \"C:\\\\Users\\\\me\\\\My Music\\\\song.wav\" -o \"C:\\\\Users\\\\me\\\\song.wt.json\"'\n+\n+ assert _split_repl_args(line) == [\n+ \"project\",\n+ \"new\",\n+ \"C:\\\\Users\\\\me\\\\My Music\\\\song.wav\",\n+ \"-o\",\n+ \"C:\\\\Users\\\\me\\\\song.wt.json\",\n+ ]\n+\n+\n+def test_repl_skin_uses_wavetone_branding_and_local_skill_path(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:\n+ skill_path = tmp_path / \"SKILL.md\"\n+ skill_path.write_text(\"# WaveTone\", encoding=\"utf-8\")\n+ skin = ReplSkin(\"WaveTone\", version=\"test\", history_file=str(tmp_path / \"history\"), skill_path=str(skill_path))\n+\n+ skin.print_banner()\n+ output = capsys.readouterr().out\n+\n+ assert skin.display_name == \"WaveTone\"\n+ assert \"WaveTone\" in output\n+ assert \"Local skill:\" in output\n+ assert \"SKILL.md\" in output\n+\n+\n+def test_repl_reports_click_exit_without_unexpected_error(monkeypatch: pytest.MonkeyPatch) -> None:\n+ errors: list[str] = []\n+ inputs = iter([\"wavetone launch\", \"exit\"])\n+\n+ class FakeSkin:\n+ def __init__(self, name: str, version: str) -> None:\n+ self.name = name\n+ self.version = version\n+\n+ def print_banner(self) -> None:\n+ return None\n+\n+ def info(self, message: str) -> None:\n+ return None\n+\n+ def create_prompt_session(self) -> object:\n+ return object()\n+\n+ def get_input(self, prompt_session: object, project_name: str, modified: bool) -> str:\n+ return next(inputs)\n+\n+ def error(self, message: str) -> None:\n+ errors.append(message)\n+\n+ def print_goodbye(self) -> None:\n+ return None\n+\n+ def fake_main(**kwargs: object) -> None:\n+ raise click.exceptions.Exit(1)\n+\n+ monkeypatch.setattr(cli_module, \"ReplSkin\", FakeSkin)\n+ monkeypatch.setattr(cli_module.cli, \"main\", fake_main)\n+\n+ result = CliRunner().invoke(cli_module.repl, [], obj={\"json\": False})\n+\n+ assert result.exit_code == 0, result.output\n+ assert errors == [\"Command exited with code 1\"]\ndiff --git a/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\nnew file mode 100644\nindex 000000000..2ceb45661\n--- /dev/null\n+++ b/wavetone/agent-harness/cli_anything/wavetone/tests/test_full_e2e.py\n@@ -0,0 +1,153 @@\n+from __future__ import annotations\n+\n+import json\n+import os\n+import shutil\n+import subprocess\n+import sys\n+from pathlib import Path\n+\n+import pytest\n+\n+from cli_anything.wavetone.tests.helpers import make_wav\n+from cli_anything.wavetone.utils import wavetone_backend\n+\n+REAL_BACKEND_ENV = \"CLI_ANYTHING_WAVETONE_REAL_BACKEND\"\n+\n+\n+def _resolve_cli(name: str, force_installed: bool = False) -> list[str]:\n+ \"\"\"Run the in-tree module by default; installed entry points are opt-in.\"\"\"\n+ module = \"cli_anything.wavetone.wavetone_cli\"\n+ if not force_installed:\n+ print(f\"[_resolve_cli] Using source module: {sys.executable} -m {module}\")\n+ return [sys.executable, \"-m\", module]\n+\n+ path = shutil.which(name)\n+ if not path:\n+ raise RuntimeError(f\"{name} not found in PATH. Install with: pip install -e .\")\n+ print(f\"[_resolve_cli] Using installed command: {path}\")\n+ return [path]\n+\n+\n+def _env_flag_enabled(name: str) -> bool:\n+ return os.environ.get(name, \"\").strip().lower() in {\"1\", \"true\", \"yes\", \"on\"}\n+\n+\n+def _real_backend_ready() -> tuple[bool, str]:\n+ if not _env_flag_enabled(REAL_BACKEND_ENV):\n+ return False, f\"set {REAL_BACKEND_ENV}=1 with WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+ if sys.platform != \"win32\":\n+ return False, \"WaveTone real-backend tests require Windows\"\n+ if not (os.environ.get(\"WAVETONE_EXE\") or os.environ.get(\"WAVETONE_HOME\")):\n+ return False, \"set WAVETONE_EXE or WAVETONE_HOME to run real backend tests\"\n+\n+ status = wavetone_backend.doctor()\n+ if status.get(\"ready\"):\n+ return True, \"\"\n+\n+ failed_checks = [check[\"name\"] for check in status.get(\"checks\", []) if not check.get(\"ok\")]\n+ reason = \", \".join(failed_checks) if failed_checks else \"WaveTone backend is not ready\"\n+ return False, f\"WaveTone real backend unavailable: {reason}\"\n+\n+\n+_REAL_BACKEND_READY, _REAL_BACKEND_SKIP_REASON = _real_backend_ready()\n+\n+\n+def test_real_backend_requires_explicit_opt_in(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.delenv(REAL_BACKEND_ENV, raising=False)\n+ monkeypatch.delenv(\"WAVETONE_EXE\", raising=False)\n+ monkeypatch.delenv(\"WAVETONE_HOME\", raising=False)\n+\n+ ready, reason = _real_backend_ready()\n+\n+ assert ready is False\n+ assert REAL_BACKEND_ENV in reason\n+\n+\n+def test_resolve_cli_defaults_to_source_module(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setenv(\"CLI_ANYTHING_FORCE_INSTALLED\", \"1\")\n+ monkeypatch.setattr(shutil, \"which\", lambda name: pytest.fail(\"default resolver should not inspect PATH\"))\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\") == [sys.executable, \"-m\", \"cli_anything.wavetone.wavetone_cli\"]\n+\n+\n+def test_resolve_cli_uses_installed_only_when_requested(monkeypatch: pytest.MonkeyPatch) -> None:\n+ monkeypatch.setattr(shutil, \"which\", lambda name: \"C:/installed/cli-anything-wavetone.exe\")\n+\n+ assert _resolve_cli(\"cli-anything-wavetone\", force_installed=True) == [\"C:/installed/cli-anything-wavetone.exe\"]\n+\n+\n+class TestCLISubprocess:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_help(self) -> None:\n+ result = self._run([\"--help\"])\n+ assert \"Agent-native CLI harness for WaveTone\" in result.stdout\n+\n+ def test_project_audio_workflow_json(self, tmp_path: Path) -> None:\n+ wav = make_wav(tmp_path / \"tone.wav\")\n+ project = tmp_path / \"tone.wt.json\"\n+\n+ result = self._run([\"--json\", \"project\", \"new\", str(wav), \"-o\", str(project)])\n+ data = json.loads(result.stdout)\n+ assert data[\"ok\"] is True\n+ assert project.exists()\n+\n+ result = self._run(\n+ [\"--project\", str(project), \"--json\", \"project\", \"set-tempo\", \"--bpm\", \"132.5\", \"--first-bar\", \"0.1\"]\n+ )\n+ assert json.loads(result.stdout)[\"tempo\"][\"bpm\"] == 132.5\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"project\", \"add-label\", \"intro\", \"--time\", \"0.25\"])\n+ assert json.loads(result.stdout)[\"labels\"][0][\"name\"] == \"intro\"\n+\n+ result = self._run([\"--project\", str(project), \"--json\", \"audio\", \"probe\"])\n+ audio = json.loads(result.stdout)[\"audio\"]\n+ assert audio[\"duration_seconds\"] == 0.5\n+ assert audio[\"channels\"] == 1\n+ print(f\"\\n Project: {project}\")\n+ print(f\" Audio: {wav} ({wav.stat().st_size:,} bytes)\")\n+\n+ def test_formats_json(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"formats\"])\n+ data = json.loads(result.stdout)\n+ assert \".wav\" in data[\"formats\"][\"extensions\"]\n+ assert \"MP3\" in data[\"formats\"][\"from_readme\"]\n+\n+\n+@pytest.mark.skipif(not _REAL_BACKEND_READY, reason=_REAL_BACKEND_SKIP_REASON)\n+class TestRealWaveToneBackend:\n+ def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:\n+ return subprocess.run(_resolve_cli(\"cli-anything-wavetone\") + args, capture_output=True, text=True, check=check)\n+\n+ def test_doctor_real_backend(self) -> None:\n+ result = self._run([\"--json\", \"wavetone\", \"doctor\"])\n+ data = json.loads(result.stdout)\n+ assert data[\"ready\"] is True\n+ assert any(check[\"name\"] == \"data/asdecoder.exe\" and check[\"ok\"] for check in data[\"checks\"])\n+ print(f\"\\n WaveTone root: {data['root']}\")\n+\n+ def test_launch_real_backend_with_wav(self, tmp_path: Path) -> None:\n+ exe = wavetone_backend.find_wavetone()\n+ wav = make_wav(tmp_path / \"launch.wav\")\n+ result = self._run(\n+ [\n+ \"--json\",\n+ \"wavetone\",\n+ \"launch\",\n+ str(wav),\n+ \"--exe\",\n+ str(exe),\n+ \"--wait\",\n+ \"1\",\n+ \"--terminate\",\n+ ]\n+ )\n+ data = json.loads(result.stdout)[\"launch\"]\n+ assert data[\"backend\"] == \"wavetone.exe\"\n+ assert data[\"audio_path\"] == str(wav.resolve())\n+ assert data[\"running_after_wait\"] is True\n+ assert data[\"terminated\"] is True\n+ print(f\"\\n Launched WaveTone PID: {data['pid']}\")\n+ print(f\" WAV: {wav} ({wav.stat().st_size:,} bytes)\")\n"},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4836,"cells":{"repo":{"kind":"string","value":"HKUDS/CLI-Anything"},"pr_number":{"kind":"number","value":308,"string":"308"},"task_type":{"kind":"string","value":"issue_to_patch"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"fix(browser): migrate DOMShell MCP integration to @apireno/domshell 2.0.0"},"pr_body":{"kind":"string","value":"## Why this matters now\n\nThe harness invokes the DOMShell MCP server via `npx @apireno/domshell` and `npx -p @apireno/domshell domshell-proxy` **without a pinned version**. `npx` resolves to the latest published version by default. DOMShell **2.0.0** shipped on 2026-05-22 and is **not backwards compatible** with the harness as written: the default MCP tool surface was consolidated from 38 per-command tools (`domshell_ls`, `domshell_cd`, `domshell_cat`, `domshell_grep`, `domshell_click`, `domshell_open`, `domshell_reload`, `domshell_back`, `domshell_forward`, `domshell_focus`, `domshell_type`) down to a single `domshell_execute` tool.\n\nThat means the next time a user runs the harness against a freshly-resolved `@apireno/domshell` from npm, every per-command MCP call returns \"tool not found\" and the harness fails. The legacy 38 tools still exist behind an opt-in `--granular` server flag, but users would have to know to pass it — there is no error path today that surfaces this. This PR removes the dependency on the per-command tools so the harness Just Works against the default 2.0.0+ server.\n\nFollow-up to #135, which fixed the per-command parameter shapes against the (then-current) 1.x API.\n\n## What changed upstream\n\n- `@apireno/domshell` default MCP tool surface: **38 per-command tools → 1 (`domshell_execute`)**. The 38 granular tools remain available behind an opt-in `--granular` server flag, but the harness no longer needs them.\n- Concurrent multi-agent: multiple MCP clients can connect simultaneously, each isolated in its own Chrome tab-group \"lane.\"\n- Optional `group_id` parameter on `domshell_execute` for explicit lane control.\n\nFull notes: [DOMShell 2.0.0 CHANGELOG](https://github.com/apireno/DOMShell/blob/main/CHANGELOG.md).\n\n## What this PR does\n\nMigrates `cli_anything/browser/utils/domshell_backend.py` from 11 per-command tool calls to a single `domshell_execute` shim. Each public Python wrapper now builds a shell-style command string (with `shlex.quote` for path/text arguments) and dispatches through one `_call_execute` helper.\n\nSide wins from the consolidation:\n- Works against DOMShell 2.0.0's default config — no user-side `--granular` requirement.\n- The `cd + grep + cd back` path-rooting pattern from #135 becomes a single multi-line `domshell_execute` call (one MCP round-trip instead of three).\n- The `focus + type` pattern from #135 likewise collapses to one call — atomic, focus state is guaranteed in place when \\`type\\` runs.\n\nUnchanged (intentionally — keeps the PR tight):\n- `domshell-proxy` spawn command (port/token args).\n- Env var contract (`DOMSHELL_TOKEN`, `DOMSHELL_PORT`).\n- Public Python API of `domshell_backend.py` (function names, return shapes; `grep` gained two backward-compatible optional kwargs).\n- `page` / `fs` / `act` / `session` CLI command groups in `browser_cli.py`.\n\n## Optional follow-up (not in this PR)\n\nDOMShell 2.0.0's `group_id` parameter could be a clean fit for the `session` command group — opt-in isolated lanes when the harness runs alongside other DOMShell consumers (e.g. a developer driving the same browser in Claude Desktop). Happy to draft a separate PR if of interest.\n\n## Testing\n\n- Unit: `pytest cli_anything/browser/tests/ -v` → **80 passed, 11 skipped** (e2e, gated on \\`DOMSHELL_E2E=1\\`), 0.36s.\n- Manual smoke against `@apireno/domshell@2.0.0` in default mode (no `--granular`): page open / fs ls / act click / fs grep all green.\n\ncc @yuh-yang @zhangxilong-43 @omerarslan0 — same areas you reviewed in #135."},"base_sha":{"kind":"string","value":"436a4f5c42452b86b64fe0373e1ed67a4347a18a"},"head_sha":{"kind":"string","value":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489"},"gold_diff":{"kind":"string","value":"diff --git a/browser/agent-harness/HARNESS.md b/browser/agent-harness/HARNESS.md\nindex 7275a41a5a..2cd1ade02a 100644\n--- a/browser/agent-harness/HARNESS.md\n+++ b/browser/agent-harness/HARNESS.md\n@@ -37,30 +37,61 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"new\"` to declare lane intent explicitly on the first call of\n+each session and reuses the captured lane id on subsequent calls (silences\n+the deprecation warning that 2.0.2 added for omitted `group_id`; will\n+become a hard error in DOMShell 3.0.0). For direct daemon-mode callers\n+without a harness `Session`, the same scheme runs at module level — the\n+first call captures a lane id into `_daemon_lane_id` and subsequent calls\n+reuse it, preserving browser state across daemon-mode no-session calls\n+(see `domshell_backend.py`'s `_daemon_lane_id` declaration for the\n+stale-lane failure mode).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |\n+| `page open <url>` | `open <url>` |\n+| `page reload` | `refresh` |\n+| `page back` | `back` |\n+| `page forward` | `forward` |\n+\n+`<restore>` resolves to `cd %here%/<harness-working-dir>` (or `cd %here%`\n+when the harness is at the tab root) so the lane's cwd ends up where\n+the harness expects.\n \n ## Key Design Decisions\n \ndiff --git a/browser/agent-harness/cli_anything/browser/browser_cli.py b/browser/agent-harness/cli_anything/browser/browser_cli.py\nindex e482c8b7da..264a1f9c9e 100644\n--- a/browser/agent-harness/cli_anything/browser/browser_cli.py\n+++ b/browser/agent-harness/cli_anything/browser/browser_cli.py\n@@ -226,6 +226,13 @@ def fs_ls(path):\n if _json_output:\n output(result)\n else:\n+ # Surface DOMShell errors (e.g. `fs ls /nonexistent`) before\n+ # falling into the empty-entries \"No elements\" branch — without\n+ # this, an error from the kernel was hidden behind a misleading\n+ # \"No elements at …\" message. (Codex P2 R4 on commit 5790651.)\n+ if \"error\" in result:\n+ click.echo(result[\"error\"], err=True)\n+ return\n entries = result.get(\"entries\", [])\n if not entries:\n click.echo(f\"No elements at {path or sess.working_dir}\")\n@@ -273,6 +280,13 @@ def fs_grep(pattern, path):\n if _json_output:\n output(result)\n else:\n+ # Surface DOMShell errors before the empty-matches \"No matches\"\n+ # branch — same fix shape as fs_ls. Without this, an anchor cd\n+ # failure on rooted grep was hidden behind \"No matches\".\n+ # (Codex P2 R4 on commit 5790651.)\n+ if \"error\" in result:\n+ click.echo(result[\"error\"], err=True)\n+ return\n matches = result.get(\"matches\", [])\n if not matches:\n click.echo(f\"No matches for '{pattern}'\")\n@@ -304,7 +318,7 @@ def act_click(path):\n \"\"\"Click an element at the given path.\"\"\"\n sess = get_session()\n use_daemon = sess.daemon_mode\n- result = backend.click(path, use_daemon=use_daemon)\n+ result = backend.click(path, use_daemon=use_daemon, session=sess)\n output(result, f\"Clicked: {path}\")\n \n \n@@ -316,7 +330,7 @@ def act_type(path, text):\n \"\"\"Type text into an input element.\"\"\"\n sess = get_session()\n use_daemon = sess.daemon_mode\n- result = backend.type_text(path, text, use_daemon=use_daemon)\n+ result = backend.type_text(path, text, use_daemon=use_daemon, session=sess)\n output(result, f\"Typed into: {path}\")\n \n \ndiff --git a/browser/agent-harness/cli_anything/browser/core/fs.py b/browser/agent-harness/cli_anything/browser/core/fs.py\nindex 303cc50072..eced7b9913 100644\n--- a/browser/agent-harness/cli_anything/browser/core/fs.py\n+++ b/browser/agent-harness/cli_anything/browser/core/fs.py\n@@ -32,7 +32,7 @@ def list_elements(session: \"Session\", path: str = \"\") -> dict:\n \"\"\"\n target_path = path if path else session.working_dir\n use_daemon = session.daemon_mode\n- return backend.ls(target_path, use_daemon=use_daemon)\n+ return backend.ls(target_path, use_daemon=use_daemon, session=session)\n \n \n def change_directory(session: \"Session\", path: str) -> dict:\n@@ -69,7 +69,7 @@ def change_directory(session: \"Session\", path: str) -> dict:\n path = session.working_dir.rstrip(\"/\") + \"/\" + path\n \n use_daemon = session.daemon_mode\n- result = backend.cd(path, use_daemon=use_daemon)\n+ result = backend.cd(path, use_daemon=use_daemon, session=session)\n # Only update working_dir if backend succeeded\n if isinstance(result, dict) and \"error\" not in result:\n new_working_dir = result.get(\"path\", path)\n@@ -93,7 +93,7 @@ def read_element(session: \"Session\", path: str = \"\") -> dict:\n \"\"\"\n target_path = path if path else session.working_dir\n use_daemon = session.daemon_mode\n- return backend.cat(target_path, use_daemon=use_daemon)\n+ return backend.cat(target_path, use_daemon=use_daemon, session=session)\n \n \n def grep_elements(session: \"Session\", pattern: str, path: str = \"\") -> dict:\n@@ -113,16 +113,11 @@ def grep_elements(session: \"Session\", pattern: str, path: str = \"\") -> dict:\n \"\"\"\n target_path = path if path else session.working_dir\n use_daemon = session.daemon_mode\n-\n- # DOMShell's grep searches from the server-side CWD. To root the search\n- # at the requested path, cd there first, grep, then restore.\n- if target_path and target_path != \"/\":\n- cd_result = backend.cd(target_path, use_daemon=use_daemon)\n- if hasattr(cd_result, 'isError') and cd_result.isError:\n- return cd_result\n-\n- try:\n- return backend.grep(pattern, use_daemon=use_daemon)\n- finally:\n- if target_path and target_path != \"/\":\n- backend.cd(session.working_dir or \"/\", use_daemon=use_daemon)\n+ prev = session.working_dir or \"/\"\n+ return backend.grep(\n+ pattern,\n+ path=target_path,\n+ prev=prev,\n+ use_daemon=use_daemon,\n+ session=session,\n+ )\ndiff --git a/browser/agent-harness/cli_anything/browser/core/page.py b/browser/agent-harness/cli_anything/browser/core/page.py\nindex 92a939eebb..c4439ad24e 100644\n--- a/browser/agent-harness/cli_anything/browser/core/page.py\n+++ b/browser/agent-harness/cli_anything/browser/core/page.py\n@@ -42,7 +42,7 @@ def open_page(session: \"Session\", url: str) -> dict:\n raise ValueError(error_msg)\n \n use_daemon = session.daemon_mode\n- result = backend.open_url(url, use_daemon=use_daemon)\n+ result = backend.open_url(url, use_daemon=use_daemon, session=session)\n session.set_url(url)\n session.set_working_dir(\"/\") # Reset to root on new page\n return result\n@@ -62,7 +62,7 @@ def reload_page(session: \"Session\") -> dict:\n {\"status\": \"reloaded\", \"url\": \"https://example.com\"}\n \"\"\"\n use_daemon = session.daemon_mode\n- result = backend.reload(use_daemon=use_daemon)\n+ result = backend.reload(use_daemon=use_daemon, session=session)\n return result\n \n \n@@ -80,7 +80,7 @@ def go_back(session: \"Session\") -> dict:\n {\"url\": \"https://previous.com\", \"status\": \"navigated\"}\n \"\"\"\n use_daemon = session.daemon_mode\n- result = backend.back(use_daemon=use_daemon)\n+ result = backend.back(use_daemon=use_daemon, session=session)\n \n # Update session state if backend returned a URL\n if isinstance(result, dict) and \"url\" in result:\n@@ -103,7 +103,7 @@ def go_forward(session: \"Session\") -> dict:\n {\"url\": \"https://next.com\", \"status\": \"navigated\"}\n \"\"\"\n use_daemon = session.daemon_mode\n- result = backend.forward(use_daemon=use_daemon)\n+ result = backend.forward(use_daemon=use_daemon, session=session)\n \n # Update session state if backend returned a URL\n if isinstance(result, dict) and \"url\" in result:\ndiff --git a/browser/agent-harness/cli_anything/browser/core/session.py b/browser/agent-harness/cli_anything/browser/core/session.py\nindex 3422f0373b..e8a5b1cb93 100644\n--- a/browser/agent-harness/cli_anything/browser/core/session.py\n+++ b/browser/agent-harness/cli_anything/browser/core/session.py\n@@ -21,6 +21,11 @@ class Session:\n - history: Stack of URLs for back navigation\n - forward_stack: Stack of URLs for forward navigation\n - daemon_mode: Whether persistent daemon connection is active\n+ - domshell_lane_id: The DOMShell 2.x lane (Chrome tab-group) the harness\n+ has been pinned to. ``None`` until the first ``_call_execute`` reply\n+ arrives carrying a ``[lane: <id>]`` marker; thereafter passed as\n+ ``group_id`` on every subsequent call so browser state (current tab,\n+ cwd, focus) persists across REPL commands in non-daemon mode.\n \"\"\"\n \n current_url: str = \"\"\n@@ -28,6 +33,7 @@ class Session:\n history: list[str] = field(default_factory=list)\n forward_stack: list[str] = field(default_factory=list)\n daemon_mode: bool = False\n+ domshell_lane_id: Optional[str] = None\n \n def set_url(self, url: str, record_history: bool = True) -> None:\n \"\"\"Set the current URL and update history.\n@@ -95,4 +101,5 @@ def status(self) -> dict:\n \"history_length\": len(self.history),\n \"forward_stack_length\": len(self.forward_stack),\n \"daemon_mode\": self.daemon_mode,\n+ \"domshell_lane_id\": self.domshell_lane_id,\n }\ndiff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},"changed_files":{"kind":"list like","value":["browser/agent-harness/HARNESS.md","browser/agent-harness/cli_anything/browser/browser_cli.py","browser/agent-harness/cli_anything/browser/core/fs.py","browser/agent-harness/cli_anything/browser/core/page.py","browser/agent-harness/cli_anything/browser/core/session.py","browser/agent-harness/cli_anything/browser/tests/test_core.py","browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py","browser/agent-harness/cli_anything/browser/utils/domshell_backend.py"],"string":"[\n \"browser/agent-harness/HARNESS.md\",\n \"browser/agent-harness/cli_anything/browser/browser_cli.py\",\n \"browser/agent-harness/cli_anything/browser/core/fs.py\",\n \"browser/agent-harness/cli_anything/browser/core/page.py\",\n \"browser/agent-harness/cli_anything/browser/core/session.py\",\n \"browser/agent-harness/cli_anything/browser/tests/test_core.py\",\n \"browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\",\n \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"`target_path` can become `None` when `path == \\\"\\\"` and `session.working_dir is None`, but `backend.grep` is typed/used as taking strings. This can lead to inconsistent behavior (e.g., bypassing the `cd` logic) and makes downstream quoting/formatting fragile. Normalize to a string, e.g., `target_path = path if path else (session.working_dir or \\\"/\\\")`, and keep `prev` consistent with that choice.","path":"browser/agent-harness/cli_anything/browser/core/fs.py","hunk":"@@ -113,16 +113,7 @@ def grep_elements(session: \"Session\", pattern: str, path: str = \"\") -> dict:\n \"\"\"\n target_path = path if path else session.working_dir\n use_daemon = session.daemon_mode\n-\n- # DOMShell's grep searches from the server-side CWD. To root the search\n- # at the requested path, cd there first, grep, then restore.\n- if target_path and target_path != \"/\":\n- cd_result = backend.cd(target_path, use_daemon=use_daemon)\n- if hasattr(cd_result, 'isError') and cd_result.isError:\n- return cd_result\n-\n- try:\n- return backend.grep(pattern, use_daemon=use_daemon)\n- finally:\n- if target_path and target_path != \"/\":\n- backend.cd(session.working_dir or \"/\", use_daemon=use_daemon)\n+ prev = session.working_dir or \"/\"\n+ return backend.grep(\n+ pattern, path=target_path, prev=prev, use_daemon=use_daemon\n+ )","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/core/fs.py b/browser/agent-harness/cli_anything/browser/core/fs.py\nindex 303cc50072..eced7b9913 100644\n--- a/browser/agent-harness/cli_anything/browser/core/fs.py\n+++ b/browser/agent-harness/cli_anything/browser/core/fs.py\n@@ -32,7 +32,7 @@ def list_elements(session: \"Session\", path: str = \"\") -> dict:\n \"\"\"\n target_path = path if path else session.working_dir\n use_daemon = session.daemon_mode\n- return backend.ls(target_path, use_daemon=use_daemon)\n+ return backend.ls(target_path, use_daemon=use_daemon, session=session)\n \n \n def change_directory(session: \"Session\", path: str) -> dict:\n@@ -69,7 +69,7 @@ def change_directory(session: \"Session\", path: str) -> dict:\n path = session.working_dir.rstrip(\"/\") + \"/\" + path\n \n use_daemon = session.daemon_mode\n- result = backend.cd(path, use_daemon=use_daemon)\n+ result = backend.cd(path, use_daemon=use_daemon, session=session)\n # Only update working_dir if backend succeeded\n if isinstance(result, dict) and \"error\" not in result:\n new_working_dir = result.get(\"path\", path)\n@@ -93,7 +93,7 @@ def read_element(session: \"Session\", path: str = \"\") -> dict:\n \"\"\"\n target_path = path if path else session.working_dir\n use_daemon = session.daemon_mode\n- return backend.cat(target_path, use_daemon=use_daemon)\n+ return backend.cat(target_path, use_daemon=use_daemon, session=session)\n \n \n def grep_elements(session: \"Session\", pattern: str, path: str = \"\") -> dict:\n@@ -113,16 +113,11 @@ def grep_elements(session: \"Session\", pattern: str, path: str = \"\") -> dict:\n \"\"\"\n target_path = path if path else session.working_dir\n use_daemon = session.daemon_mode\n-\n- # DOMShell's grep searches from the server-side CWD. To root the search\n- # at the requested path, cd there first, grep, then restore.\n- if target_path and target_path != \"/\":\n- cd_result = backend.cd(target_path, use_daemon=use_daemon)\n- if hasattr(cd_result, 'isError') and cd_result.isError:\n- return cd_result\n-\n- try:\n- return backend.grep(pattern, use_daemon=use_daemon)\n- finally:\n- if target_path and target_path != \"/\":\n- backend.cd(session.working_dir or \"/\", use_daemon=use_daemon)\n+ prev = session.working_dir or \"/\"\n+ return backend.grep(\n+ pattern,\n+ path=target_path,\n+ prev=prev,\n+ use_daemon=use_daemon,\n+ session=session,\n+ )\n"},{"comment":"The new parameter name `prev` is ambiguous in a public wrapper API (it’s not obvious it means the cwd-to-restore-after-search). Consider renaming it to something more explicit like `restore_cwd`/`restore_path`/`cwd_before` to reduce misuse and improve readability at call sites.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -275,17 +289,28 @@ def cat(path: str, use_daemon: bool = False) -> dict:\n >>> cat(\"/main/button[0]\")\n {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(f\"cat {_q(path)}\", use_daemon))\n \n \n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n+def grep(\n+ pattern: str,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+) -> dict:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"Previously, `grep_elements` restored the cwd in a Python `finally:` block, guaranteeing the session/server cwd is restored even if `grep` fails. With the new multi-line command approach, restoring cwd now depends on `domshell_execute` continuing to execute subsequent lines after an error. To avoid leaving the server cwd changed on failure, consider detecting an error result and issuing a best-effort follow-up `cd <prev>` (or reverting to a two-step approach only on error).","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -294,13 +319,14 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\n Example:\n >>> grep(\"Login\")\n {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\", path=\"/main\")\n+ {\"matches\": [\"/main/button[0]\"]}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n- ))\n- return result\n+ if path and path != \"/\":\n+ command = f\"cd {_q(path)}\\ngrep {_q(pattern)}\\ncd {_q(prev)}\"\n+ else:\n+ command = f\"grep {_q(pattern)}\"\n+ return asyncio.run(_call_execute(command, use_daemon))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`type_text` uses a newline as a command separator. If `text` itself contains a newline, `_q(text)` will include that newline and can unintentionally split the command into additional lines, changing behavior or causing parse errors. To make this safe, either (a) escape/encode newlines in `text` in a way DOMShell understands, or (b) explicitly reject multi-line `text` with a clear error and provide an alternative method for multi-line input.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -392,23 +414,8 @@ def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n Returns:\n Dict with action result\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n- )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- return asyncio.run(_focus_and_type())\n+ command = f\"focus {_q(path)}\\ntype {_q(text)}\"\n+ return asyncio.run(_call_execute(command, use_daemon))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The `is_available()` example hard-codes `v2.0.0`, but (based on the snippet shown) this function appears to be a generic availability check rather than an explicit minimum-version gate. Either (1) update `is_available()` to actually validate `>= 2.0.0` if that’s now required, or (2) make the example/version wording generic to avoid implying a version guarantee.\n","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -78,7 +84,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell v2.0.0 is available\")","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The new behavior builds and sends multi-line command strings (including quoting) via `_call_execute`, but the existing tests only validate higher-level calls into `backend.grep` (and not what command string is produced). Add unit coverage that patches `_call_execute` to assert the exact `command` produced for both cases: rooted search (`cd ...\\\\ngrep ...\\\\ncd ...`) and default search (`grep ...`), including at least one case with spaces/special characters to validate quoting.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -294,13 +319,14 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\n Example:\n >>> grep(\"Login\")\n {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\", path=\"/main\")\n+ {\"matches\": [\"/main/button[0]\"]}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n- ))\n- return result\n+ if path and path != \"/\":\n+ command = f\"cd {_q(path)}\\ngrep {_q(pattern)}\\ncd {_q(prev)}\"\n+ else:\n+ command = f\"grep {_q(pattern)}\"\n+ return asyncio.run(_call_execute(command, use_daemon))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Preserve positional compatibility for grep use_daemon arg**\n\nChanging `grep` from `grep(pattern, use_daemon=False)` to `grep(pattern, path=\"\", prev=\"/\", use_daemon=False)` breaks existing positional callers: a call like `grep(\"Login\", True)` now binds `True` to `path` instead of `use_daemon`, producing a `cd True` command sequence and disabling daemon mode. This is a runtime regression for any downstream code using the previously valid positional form, despite the API being described as unchanged.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -275,17 +289,28 @@ def cat(path: str, use_daemon: bool = False) -> dict:\n >>> cat(\"/main/button[0]\")\n {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(f\"cat {_q(path)}\", use_daemon))\n \n \n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n+def grep(\n+ pattern: str,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Reject newlines before quoting DOMShell arguments**\n\nBecause `domshell_execute` splits commands on newlines before shell-style quote parsing (as noted in `_assert_single_line`), `shlex.quote` alone does not protect the single-command wrappers. Inputs like `open_url(\"https://example.com\\nclick /admin\")`, `click(\"/safe\\nopen https://evil.test\")`, or unrooted `grep(\"x\\nclick /admin\")` are quoted with an embedded newline and become multiple DOMShell commands; only `type_text` and rooted `grep` currently reject these characters. Centralizing the newline check in `_q` (or applying it to every wrapper) would close the injection path introduced by switching from structured MCP arguments to command strings.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,16 +116,57 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n-) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\"\"\"\n+ return shlex.quote(arg)","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"When `use_daemon=False`, each `asyncio.run(_call_execute(...))` spawns a brand-new MCP server subprocess (see `_call_execute`'s `stdio_client(server_params)` branch). DOMShell's cwd lives in that server process, so the leading `cd {path}` is discarded with the subprocess before the subsequent `grep` runs — the grep ends up rooted at the default cwd, not at `path`, and the trailing `cd {prev}` is a no-op. The rooted-grep contract only holds in daemon mode. Either send all three commands in a single multi-line `domshell_execute` call (which is also the one-round-trip win the docstring already alludes to), or guard the multi-call form behind `use_daemon=True` and raise/fallback otherwise. The existing tests don't catch this because they mock `_call_execute` and never exercise the subprocess-per-call behavior.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -294,13 +386,21 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\n Example:\n >>> grep(\"Login\")\n {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\", path=\"/main\")\n+ {\"matches\": [\"/main/button[0]\"]}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n- ))\n- return result\n+ if path and path != \"/\":\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"prev\", prev)\n+ _assert_single_line(\"pattern\", pattern)\n+ cd_result = asyncio.run(_call_execute(f\"cd {_q(path)}\", use_daemon))\n+ if _is_error(cd_result):\n+ return cd_result\n+ try:\n+ return asyncio.run(_call_execute(f\"grep {_q(pattern)}\", use_daemon))\n+ finally:\n+ asyncio.run(_call_execute(f\"cd {_q(prev)}\", use_daemon))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The substring heuristic produces false positives for any legitimate result whose first text content starts with \"error\" (e.g., a `grep \"error\"` match list, a `cat` of an element labeled \"Error message\", a page title containing \"Error\"). Because `_is_error` gates the rooted-`grep` short-circuit, a successful `cd` whose response text happens to start with \"error\" would cause `grep_elements` to skip the actual grep and return the cd response as if it were a failure. Prefer relying solely on the structured signals (`isError` attribute / `isError` or `error` dict keys) and dropping the text-prefix fallback, or restrict the textual check to a strict format DOMShell actually emits (e.g., `\"Error:\"` exactly).","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,16 +116,76 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n-) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got: {arg!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Best-effort check that a ``domshell_execute`` result represents an error.\n+\n+ Inspects ``isError`` if the MCP SDK populated it; otherwise scans the\n+ concatenated text content for a leading \"error\". Robust to both the\n+ raw ``CallToolResult`` object and the dict shapes used in unit tests.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\"):\n+ return True\n+ if \"error\" in result:\n+ return True\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text.strip().lower().startswith(\"error\")","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"Dropping the bound exception name means every failure on the daemon path — not just a dead connection — is silently swallowed and retried via a fresh subprocess, with no signal in logs about what went wrong. A transient daemon-side bug or a programming error in the arguments will look like an unrelated MCP failure when the spawn path also fails. Consider keeping `except Exception as e:` and logging it at debug/warning level before falling back, so daemon-only regressions are diagnosable.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -133,9 +199,11 @@ async def _call_tool(\n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", {\"command\": command}\n+ )\n return result\n- except Exception as e:\n+ except Exception:\n # Daemon died, fall back to spawning new server\n await _stop_daemon()","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The default for `path` is `\"/\"` (not `\"\"`), so the `if path` branch is always taken and the `else \"ls\"` arm is unreachable for callers using the default. If the intent is to fall back to a bare `ls` on empty input, also test for `path == \"\"` explicitly (e.g., `if path and path != \"\"`) — or just always emit `f\"ls {_q(path)}\"` and drop the dead branch.\n","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -239,8 +313,8 @@ def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n >>> ls(\"/\")\n {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n+ command = f\"ls {_q(path)}\" if path else \"ls\"","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Keep rooted grep in one MCP session**\n\nIn non-daemon mode, each `_call_execute` opens and initializes a fresh stdio `ClientSession`, and DOMShell 2 isolates state per MCP client/lane; as a result the `cd` here does not carry over to the subsequent `grep` call. Any `fs grep` scoped to a non-root path or current working directory will search from the new session's default cwd instead, while the final restore also runs in yet another session. This needs to use one `domshell_execute` call (or another single-session sequence) for `cd` + `grep` + restore.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -294,13 +386,21 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\n Example:\n >>> grep(\"Login\")\n {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\", path=\"/main\")\n+ {\"matches\": [\"/main/button[0]\"]}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n- ))\n- return result\n+ if path and path != \"/\":\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"prev\", prev)\n+ _assert_single_line(\"pattern\", pattern)\n+ cd_result = asyncio.run(_call_execute(f\"cd {_q(path)}\", use_daemon))\n+ if _is_error(cd_result):\n+ return cd_result\n+ try:\n+ return asyncio.run(_call_execute(f\"grep {_q(pattern)}\", use_daemon))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Reuse DOMShell lane across non-daemon calls**\n\nIn the default `use_daemon=False` path this opens a brand-new MCP `ClientSession` for every wrapper call, but DOMShell 2 assigns each MCP client its own fresh lane/group. That means ordinary REPL workflows without `--daemon`, such as `page open https://example.com` followed by `fs ls` or `act click`, execute the second command in a different fresh lane instead of the tab opened by the first command. Persist the DOMShell `group_id` returned by `domshell_execute` or keep a session per CLI session so non-daemon mode preserves browser state across commands.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -149,7 +193,9 @@ async def _call_tool(\n async with stdio_client(server_params) as (read, write):\n async with ClientSession(read, write) as session:\n await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ result = await session.call_tool(\n+ \"domshell_execute\", {\"command\": command}\n+ )","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"These imports are placed in the middle of the module (after numerous test definitions) rather than at the top with the other imports. Move `SimpleNamespace` and `Session` up to the existing import block at the top of the file to follow PEP 8 and avoid surprising readers/tools that expect all imports to be grouped at the top.","path":"browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py","hunk":"@@ -0,0 +1,414 @@\n+\"\"\"Wire-format tests for cli_anything.browser.utils.domshell_backend.\n+\n+These tests patch the async ``_call_execute`` helper and assert the exact\n+command string sent to the DOMShell ``domshell_execute`` tool, so wire-format\n+regressions (quoting, command names, multi-line layout, restore ordering)\n+fail loudly.\n+\"\"\"\n+\n+import pytest\n+from unittest.mock import AsyncMock, call, patch\n+\n+from cli_anything.browser.utils import domshell_backend as backend\n+\n+\n+# ── grep: command string and call sequencing ──────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_produces_single_grep_call(mock_call):\n+ \"\"\"Unrooted grep dispatches one ``grep <pattern>`` call.\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"Login\")\n+\n+ # session=None when no session is passed (default).\n+ assert mock_call.call_args_list == [call(\"grep Login\", False, session=None)]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_emits_single_multiline_call(mock_call):\n+ \"\"\"Rooted grep is ONE multi-line ``cd / grep / cd back`` execute call.\n+\n+ Each ``_call_execute`` in non-daemon mode opens a fresh MCP session\n+ that lands in its own DOMShell 2.x lane, so splitting cd / grep /\n+ restore across separate calls would lose the cwd between them. The\n+ three lines must travel in one ``domshell_execute`` call to share\n+ a lane.\n+ \"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\")\n+\n+ assert mock_call.call_args_list == [\n+ call(\"cd /main\\ngrep Login\\ncd /\", False, session=None),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_uses_single_call_for_lane_isolation(mock_call):\n+ \"\"\"Documents the lane-isolation contract: ONE call, not three.\n+\n+ The trailing ``cd prev`` is delivered as the final line of the same\n+ multi-line command and runs even if ``grep`` errors, per DOMShell's\n+ documented continue-on-error semantics\n+ (`apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+ \"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\")\n+\n+ assert mock_call.call_count == 1\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_quotes_path_with_spaces(mock_call):\n+ \"\"\"Paths with whitespace are shell-quoted inside the multi-line command.\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"Login\", path=\"/path with spaces\", prev=\"/\")\n+\n+ cmd = mock_call.call_args.args[0]\n+ # shlex.quote single-quotes anything containing whitespace; the rest\n+ # of the multi-line layout (grep + cd back) stays intact.\n+ assert cmd.startswith(\"cd '/path with spaces'\\n\")\n+ assert \"\\ngrep Login\\n\" in cmd\n+ assert cmd.endswith(\"\\ncd /\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_pattern_with_shell_metacharacters_quoted(mock_call):\n+ \"\"\"Patterns with shell metacharacters get quoted (no injection via grep).\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"$(rm -rf /)\")\n+\n+ grep_cmd = mock_call.call_args_list[0].args[0]\n+ # shlex.quote will single-quote the dangerous payload.\n+ assert grep_cmd == \"grep '$(rm -rf /)'\"\n+\n+\n+def test_grep_rejects_positional_path():\n+ \"\"\"grep(pattern, path) — positional path raises TypeError.\n+\n+ Pre-migration callers writing ``grep(\"Login\", True)`` to mean\n+ ``use_daemon=True`` must not silently get ``path=True``.\n+ \"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", True) # type: ignore[misc]\n+\n+\n+def test_grep_rejects_positional_use_daemon():\n+ \"\"\"Even the third positional slot is blocked.\"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", \"/main\", \"/\", True) # type: ignore[misc]\n+\n+\n+def test_grep_keyword_use_daemon_still_works():\n+ \"\"\"Keyword call against the new signature still type-checks at call time.\"\"\"\n+ with patch.object(backend, \"_call_execute\", new_callable=AsyncMock) as mock_call:\n+ mock_call.return_value = {}\n+ backend.grep(\"Login\", use_daemon=True)\n+ assert mock_call.call_args_list == [call(\"grep Login\", True, session=None)]\n+\n+\n+# ── type_text: focus+type pairing and newline injection guard ─────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_emits_focus_then_type_in_one_call(mock_call):\n+ \"\"\"type_text builds a single multi-line ``focus … \\\\ntype …`` execute call.\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.type_text(\"search_input\", \"machine learning\")\n+\n+ assert mock_call.call_args_list == [\n+ call(\"focus search_input\\ntype 'machine learning'\", False, session=None),\n+ ]\n+\n+\n+def test_type_text_rejects_newline_in_text():\n+ \"\"\"``\\\\n`` in text would inject a new DOMShell command — must raise.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\nline2\")\n+\n+\n+def test_type_text_rejects_carriage_return_in_text():\n+ \"\"\"``\\\\r`` is just as dangerous as ``\\\\n`` for DOMShell's line splitter.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\rline2\")\n+\n+\n+def test_type_text_rejects_newline_in_path():\n+ \"\"\"A newline in the path argument also injects — guard both fields.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"input\\nclick /admin\", \"anything\")\n+\n+\n+# ── grep: newline guard on rooted multi-step path ─────────────────────\n+\n+\n+def test_grep_rejects_newline_in_path():\n+ \"\"\"Rooted grep interpolates path into a multi-line cd/grep/cd — reject newlines.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\\nclick /admin\", prev=\"/\")\n+\n+\n+def test_grep_rejects_newline_in_pattern():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\\nclick /admin\", path=\"/main\", prev=\"/\")\n+\n+\n+def test_grep_rejects_newline_in_prev():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\\nclick /admin\")\n+\n+\n+# ── Centralized newline guard in _q ──────────────────────────────────\n+#\n+# The per-wrapper _assert_single_line calls above cover type_text and\n+# rooted grep with field-named error messages. The newline check inside\n+# _q itself catches the same class of injection for every OTHER wrapper\n+# that flows user input through the quoting layer (open_url, click, cd,\n+# cat, unrooted grep, etc.) — without needing a per-call guard at each\n+# site.\n+\n+\n+def test_q_rejects_line_feeds():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\nbar\")\n+\n+\n+def test_q_rejects_carriage_returns():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\rbar\")\n+\n+\n+def test_q_accepts_normal_strings():\n+ \"\"\"Plain strings pass through to shlex.quote unchanged.\"\"\"\n+ assert backend._q(\"simple\") == \"simple\"\n+ assert backend._q(\"hello world\") == \"'hello world'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_unrooted_grep_pattern_rejects_newlines(mock_call):\n+ \"\"\"The unrooted grep path was not field-guarded — _q catches it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.grep(\"evil\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_open_url_rejects_newlines(mock_call):\n+ \"\"\"open_url has no per-call _assert_single_line — _q must catch it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.open_url(\"https://example.com\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_rejects_newlines(mock_call):\n+ \"\"\"click is covered structurally by _q without a per-call guard.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.click(\"/main/button[0]\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_rejects_newlines(mock_call):\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.cd(\"/main\\nclick /admin\")\n+\n+\n+# ── DOMShell lane persistence across _call_execute calls ─────────────\n+#\n+# DOMShell 2.x assigns a fresh lane (Chrome tab-group) to every new MCP\n+# session. In non-daemon mode each _call_execute opens its own stdio\n+# ClientSession, so without explicit group_id every command would land\n+# in a brand-new lane and lose browser state from the previous call.\n+# The fix: parse the trailing \"[lane: <id>]\" marker DOMShell appends to\n+# each reply, store it on the harness Session, and pass group_id=<id>\n+# on every subsequent call.\n+\n+\n+from types import SimpleNamespace\n+\n+from cli_anything.browser.core.session import Session","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py b/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\nnew file mode 100644\nindex 0000000000..2b75fe0097\n--- /dev/null\n+++ b/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\n@@ -0,0 +1,1337 @@\n+\"\"\"Wire-format tests for cli_anything.browser.utils.domshell_backend.\n+\n+These tests patch the async ``_call_execute`` helper and assert the exact\n+command string sent to the DOMShell ``domshell_execute`` tool, so wire-format\n+regressions (quoting, command names, multi-line layout, restore ordering)\n+fail loudly.\n+\"\"\"\n+\n+from types import SimpleNamespace\n+from unittest.mock import AsyncMock, call, patch\n+\n+import pytest\n+\n+from cli_anything.browser.core.session import Session\n+from cli_anything.browser.utils import domshell_backend as backend\n+\n+\n+# ── Path translation: harness `/` vs DOMShell `~/` ───────────────────\n+\n+\n+def test_translate_path_root_is_absolute_empty():\n+ \"\"\"`/` → (\"\", True). Absolute target with no further subdir.\"\"\"\n+ assert backend._translate_path(\"/\") == (\"\", True)\n+\n+\n+def test_translate_path_empty_is_relative_empty():\n+ \"\"\"`\"\"` → (\"\", False). Bare/relative no-op; caller decides what to do.\"\"\"\n+ assert backend._translate_path(\"\") == (\"\", False)\n+\n+\n+def test_translate_path_strips_all_leading_slashes():\n+ \"\"\"`//main` collapses to `(\"main\", True)` via lstrip.\"\"\"\n+ assert backend._translate_path(\"/main\") == (\"main\", True)\n+ assert backend._translate_path(\"//main\") == (\"main\", True)\n+ assert backend._translate_path(\"///main\") == (\"main\", True)\n+\n+\n+def test_translate_path_preserves_relative():\n+ \"\"\"Relative paths pass through unchanged — DOMShell handles them.\"\"\"\n+ assert backend._translate_path(\"main\") == (\"main\", False)\n+ assert backend._translate_path(\"..\") == (\"..\", False)\n+ assert backend._translate_path(\".\") == (\".\", False)\n+\n+\n+# ── ls / cd / cat / click: absolute paths anchor at %here% ───────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_path_uses_three_separate_calls(mock_call):\n+ \"\"\"Split-and-check: anchor → bare ls → restore, three distinct calls.\n+\n+ Anchor success is load-bearing — if the cd fails, ls would run in\n+ the wrong cwd. Tested separately by\n+ test_ls_anchor_failure_short_circuits.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.ls(\"/main\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\" # anchor\n+ assert mock_call.call_args_list[1].args[0] == \"ls\" # op\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\" # restore\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_root_from_drifted_cwd_anchors_at_here(mock_call):\n+ \"\"\"The Codex P1 case: `ls /` from a drifted `/main` cwd.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.ls(\"/\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\" # anchor at tab root\n+ assert mock_call.call_args_list[1].args[0] == \"ls\" # bare ls\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\" # back to /main\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_relative_path_no_wrap(mock_call):\n+ \"\"\"Relative `ls main` runs against lane cwd — no anchor, no restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"main\")\n+ assert mock_call.call_args.args[0] == \"ls main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_path_with_spaces_quoted(mock_call):\n+ \"\"\"The `%here%/<deeper>` token is shell-quoted as one unit.\n+\n+ Upstream-smoked: `cd '%here%/<path>'` works in DOMShell 2.0.x — so\n+ whitespace and other shell metachars in absolute targets are safe.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/path with spaces\", session=_make_session(working_dir=\"/\"))\n+ # Anchor (first call) is the quoted form.\n+ assert mock_call.call_args_list[0].args[0] == \"cd '%here%/path with spaces'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_root_uses_here(mock_call):\n+ \"\"\"`cd /` → `cd %here%`. Single line — cd's purpose IS the new state.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/\")\n+ assert mock_call.call_args.args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_absolute_is_single_line_no_restore(mock_call):\n+ \"\"\"`cd /main` → `cd %here%/main`. One line, no restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/main\")\n+ assert mock_call.call_args.args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_subpath_with_indexing(mock_call):\n+ \"\"\"Brackets are shell-metachars — `_here_path` quotes the full token.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/main/div[0]\")\n+ assert mock_call.call_args.args[0] == \"cd '%here%/main/div[0]'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_relative_quoted(mock_call):\n+ \"\"\"Relative `cd main` is quoted via _q (handles spaces / metachars).\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"main\")\n+ assert mock_call.call_args.args[0] == \"cd main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_absolute_path_uses_three_separate_calls(mock_call):\n+ \"\"\"`cat /main/btn`: anchor at tab root → cat main/btn → restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+ backend.cat(\"/main/btn\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"cat main/btn\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_relative_no_wrap(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cat(\"main/btn\")\n+ assert mock_call.call_args.args[0] == \"cat main/btn\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_root_path_does_not_raise_and_returns_parseable_result(mock_call):\n+ \"\"\"backend.cat(\"/\") and backend.cat(\"\") at the absolute root should\n+ NOT raise a Python ValueError. Pre-migration behavior was to send\n+ ``cat ''`` to DOMShell and surface its ``Usage: cat <name>`` error\n+ string; the round-5 Python-side guard converted the kernel error\n+ into a ValueError, which broke ``fs.read_element(session, \"\")``\n+ callers landed at ``/``. @yuh-yang R3 blocker 1 required restoring\n+ pre-migration behavior — guard removed, both inputs now reach\n+ DOMShell, which has the same ``if (!targetName)`` check and\n+ returns its standard Usage error.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mUsage: cat <name> (see cat --help)\\x1b[0m\\n[lane: shared]\"\n+ )\n+ sess = _make_session(working_dir=\"/\") # satisfies absolute branch's session check\n+\n+ # MUST NOT raise — that was the regression.\n+ result_root = backend.cat(\"/\", session=sess)\n+ result_empty = backend.cat(\"\")\n+\n+ # Both surface DOMShell's error as a parsed dict, not a Python exception.\n+ for r in (result_root, result_empty):\n+ assert isinstance(r, dict)\n+ # _parse_execute_result detects ANSI red → routes through error path.\n+ assert \"error\" in r\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_absolute_path_uses_three_separate_calls(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.click(\"/main/button[0]\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"click 'main/button[0]'\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_relative_no_wrap(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.click(\"button[0]\")\n+ assert mock_call.call_args.args[0] == \"click 'button[0]'\"\n+\n+\n+def test_click_root_raises_value_error():\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.click(\"/\")\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.click(\"\")\n+\n+\n+# ── grep absolute-path anchoring ─────────────────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_absolute_uses_three_separate_calls(mock_call):\n+ \"\"\"Rooted grep (absolute): anchor → grep → restore, three distinct calls.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\n+ \"Login\", path=\"/main\", prev=\"/\", session=_make_session(working_dir=\"/\"),\n+ )\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\"\n+ assert mock_call.call_args_list[1].args[0] == \"grep -r Login\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_absolute_restores_to_session_wd(mock_call):\n+ \"\"\"Restore (third call) follows session.working_dir, not the `prev`\n+ kwarg, when the path is absolute — the lane cwd needs to end up\n+ where the harness thinks it is.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\n+ \"Login\", path=\"/main\", prev=\"/\", session=_make_session(working_dir=\"/main\"),\n+ )\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+\n+\n+# ── Anchor-failure short-circuit (the Codex P2 case per-wrapper) ─────\n+#\n+# If the anchor `cd` fails, the operation must NOT run — it would\n+# resolve against the wrong cwd and produce wrong-target results. Each\n+# wrapper that uses split-and-check mirrors `type_text`'s\n+# anchor-failure pattern.\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_anchor_failure_short_circuits(mock_call):\n+ \"\"\"ls absolute-path anchor failure → only the anchor call ran.\n+\n+ Uses DOMShell's actual error shape: ANSI-red-wrapped, command-\n+ prefixed (\"cd: ...\") — not the imaginary \"Error: ...\" prefix that\n+ silently bypassed ``_is_error`` for several rounds.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: tab 12345 is outside the session group\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.ls(\"/main\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_anchor_failure_short_circuits(mock_call):\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.cat(\"/main/btn\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_anchor_failure_short_circuits(mock_call):\n+ \"\"\"Critical for click: a misdirected click could trigger an\n+ unintended action. Anchor must halt before the click runs.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.click(\"/main/button[0]\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_anchor_failure_short_circuits(mock_call):\n+ \"\"\"Rooted grep with anchor failure → grep doesn't run (wrong-scope\n+ matches would be misleading). Restore also skipped because we\n+ never moved off the original cwd.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: /missing: No such directory\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.grep(\"Login\", path=\"/missing\", prev=\"/\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/missing\"\n+ assert \"error\" in result\n+\n+\n+# ── Absolute split-and-check requires session in non-daemon mode ─────\n+#\n+# Without a session (and without daemon mode), each `_call_execute` lands\n+# in a fresh DOMShell lane — the anchor cd's cwd doesn't carry over to\n+# the operation, producing wrong-scope output. Raise up front to surface\n+# the misuse instead of silently producing wrong results. (Mirrors\n+# `type_text`'s round-6.1 guard; propagated to ls/cat/click/grep in\n+# round 7.2 per Codex P2 #2.)\n+\n+\n+def test_ls_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.ls(\"/main\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_with_daemon_no_session_works(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — no\n+ session required.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/main\", use_daemon=True, session=None)\n+ # 3-call split-and-check still happens.\n+ assert mock_call.call_count == 3\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_relative_without_session_works(mock_call):\n+ \"\"\"Relative path runs as a single call — no anchor, no lane drift\n+ risk, so session=None is fine in non-daemon mode.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"main\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_cat_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.cat(\"/main/btn\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_relative_without_session_works(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cat(\"main/btn\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_click_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.click(\"/main/button[0]\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_relative_without_session_works(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.click(\"button[0]\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_grep_rooted_absolute_without_session_raises_in_non_daemon():\n+ \"\"\"Rooted grep with absolute path requires session for lane consistency.\"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\", session=None)\n+\n+\n+def test_grep_rooted_relative_without_session_raises_in_non_daemon():\n+ \"\"\"Rooted grep with RELATIVE path also requires session — both\n+ branches issue 3 separate calls and depend on shared lane state.\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.grep(\"Login\", path=\"dialog\", prev=\"/main\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_relative_with_daemon_no_session_works(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — no\n+ session required even for relative-rooted grep.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", path=\"dialog\", prev=\"/main\", use_daemon=True, session=None)\n+ # 3-call split-and-check still happens.\n+ assert mock_call.call_count == 3\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_without_session_works(mock_call):\n+ \"\"\"Unrooted grep is a single call — no session required.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+# ── _parse_execute_result: dict shapes per command ───────────────────\n+#\n+# DOMShell 2.x returns text content; the CLI was written for the\n+# pre-2.0 per-command tools that returned dicts. These tests lock in\n+# the translator's per-command shape contract so the CLI doesn't break\n+# on `result.get(...)` calls.\n+\n+\n+def test_parse_execute_result_ls_extracts_entries():\n+ result = _make_result(\"button[0]\\nlink[1]\\nimg[2]\\n[lane: 7]\")\n+ parsed = backend._parse_execute_result(result, \"ls\")\n+ assert parsed[\"entries\"] == [\n+ {\"name\": \"button[0]\", \"role\": \"\", \"path\": \"button[0]\"},\n+ {\"name\": \"link[1]\", \"role\": \"\", \"path\": \"link[1]\"},\n+ {\"name\": \"img[2]\", \"role\": \"\", \"path\": \"img[2]\"},\n+ ]\n+ # Lane marker is stripped from the raw text.\n+ assert \"[lane:\" not in parsed[\"raw\"]\n+\n+\n+def test_parse_execute_result_ls_empty_text_returns_empty_entries():\n+ parsed = backend._parse_execute_result(_make_result(\"[lane: 7]\"), \"ls\")\n+ assert parsed == {\"entries\": [], \"raw\": \"\"}\n+\n+\n+def test_parse_execute_result_grep_extracts_matches():\n+ result = _make_result(\n+ \"/main/button[0]\\n/main/link[1]\\n[lane: 7]\"\n+ )\n+ parsed = backend._parse_execute_result(result, \"grep\")\n+ assert parsed[\"matches\"] == [\"/main/button[0]\", \"/main/link[1]\"]\n+ assert \"[lane:\" not in parsed[\"raw\"]\n+\n+\n+def test_parse_execute_result_error_returns_error_dict():\n+ \"\"\"Errors get `error` AND `output` keys — the CLI checks `\"error\" in\n+ result` for cd-style guards but also pretty-prints `output`.\n+\n+ Uses the actual DOMShell error shape: ANSI-red-wrapped, command-\n+ prefixed (``ls: ...``).\n+ \"\"\"\n+ result = _make_result(\n+ \"\\x1b[31mls: main: No such directory\\x1b[0m\\n[lane: 7]\"\n+ )\n+ parsed = backend._parse_execute_result(result, \"ls\")\n+ assert \"error\" in parsed\n+ assert parsed[\"error\"].startswith(\"\\x1b[31mls:\")\n+ assert parsed[\"output\"] == parsed[\"error\"]\n+\n+\n+def test_parse_execute_result_default_for_non_nav_commands():\n+ \"\"\"cat/click/focus/type/refresh fall through to the generic\n+ ``{\"output\": text}`` shape (nav commands get their own branch —\n+ see test_parse_execute_result_nav_*).\"\"\"\n+ for cmd in (\"cat\", \"click\", \"focus\", \"type\", \"refresh\"):\n+ parsed = backend._parse_execute_result(\n+ _make_result(\"done\\n[lane: 1]\"), cmd,\n+ )\n+ assert parsed == {\"output\": \"done\"}\n+\n+\n+# ── Nav commands (back/forward/navigate/open): URL/title extraction ──\n+\n+\n+def test_parse_execute_result_nav_extracts_url_and_title():\n+ \"\"\"back/forward/navigate/open extract `url` and `title` so\n+ page.go_back/go_forward's `\"url\" in result` guards fire and\n+ session.set_url updates correctly. (Codex P2 #1.)\n+ \"\"\"\n+ fixture = _make_result(\n+ \"✓ Navigated back\\n\"\n+ \"URL: https://example.com/page\\n\"\n+ \"Title: Example Page\\n\"\n+ \"[lane: 7]\"\n+ )\n+ for cmd in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ parsed = backend._parse_execute_result(fixture, cmd)\n+ assert parsed[\"url\"] == \"https://example.com/page\"\n+ assert parsed[\"title\"] == \"Example Page\"\n+ # The raw output is preserved alongside.\n+ assert \"✓ Navigated back\" in parsed[\"output\"]\n+\n+\n+def test_parse_execute_result_nav_omits_url_when_missing():\n+ \"\"\"Malformed/early response without URL line → `output` only, no crash.\"\"\"\n+ parsed = backend._parse_execute_result(_make_result(\"✓ done\\n[lane: 1]\"), \"back\")\n+ assert parsed == {\"output\": \"✓ done\"}\n+ assert \"url\" not in parsed\n+ assert \"title\" not in parsed\n+\n+\n+def test_parse_execute_result_nav_extracts_url_without_title():\n+ \"\"\"A response with URL but no Title line still extracts the URL.\"\"\"\n+ parsed = backend._parse_execute_result(\n+ _make_result(\"URL: https://example.com/x\\n[lane: 1]\"), \"open\",\n+ )\n+ assert parsed[\"url\"] == \"https://example.com/x\"\n+ assert \"title\" not in parsed\n+\n+\n+def test_parse_execute_result_nav_title_handles_trailing_whitespace():\n+ \"\"\"Title regex strips trailing newline/whitespace.\"\"\"\n+ parsed = backend._parse_execute_result(\n+ _make_result(\n+ \"URL: https://example.com\\n\"\n+ \"Title: Spaced Title \\n\"\n+ \"[lane: 1]\"\n+ ),\n+ \"open\",\n+ )\n+ assert parsed[\"title\"] == \"Spaced Title\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_back_returns_dict_with_url_key(mock_call):\n+ \"\"\"End-to-end: backend.back() returns a dict with `url` so\n+ page.go_back's guard fires. (The Codex P2 #1 regression case.)\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\n+ \"✓ Navigated back\\n\"\n+ \"URL: https://previous.com\\n\"\n+ \"Title: Previous\\n\"\n+ \"[lane: 1]\"\n+ )\n+ result = backend.back(session=sess)\n+ assert \"url\" in result\n+ assert result[\"url\"] == \"https://previous.com\"\n+ assert result[\"title\"] == \"Previous\"\n+\n+\n+# ── End-to-end: wrappers return parsed dicts (not CallToolResult) ────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_returns_entries_dict(mock_call):\n+ \"\"\"`backend.ls(...)` must return ``{\"entries\": [...]}`` so the CLI\n+ doesn't AttributeError on `result.get(\"entries\", [])`. This is the\n+ Codex P1 shipped regression.\"\"\"\n+ mock_call.return_value = _make_result(\"button[0]\\n[lane: 1]\")\n+ result = backend.ls(\"main\")\n+ assert \"entries\" in result\n+ assert isinstance(result[\"entries\"], list)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_returns_matches_dict(mock_call):\n+ mock_call.return_value = _make_result(\"/main/btn[0]\\n[lane: 1]\")\n+ result = backend.grep(\"Login\")\n+ assert \"matches\" in result\n+ assert result[\"matches\"] == [\"/main/btn[0]\"]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_returns_dict_with_output(mock_call):\n+ \"\"\"`backend.cd(...)` returns a dict so `isinstance(result, dict)`\n+ in fs.change_directory works and `result.get(\"path\", path)` falls\n+ back cleanly.\"\"\"\n+ mock_call.return_value = _make_result(\"✓ Entered main\\n[lane: 1]\")\n+ result = backend.cd(\"/main\")\n+ assert isinstance(result, dict)\n+ assert \"error\" not in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_error_returns_error_dict(mock_call):\n+ \"\"\"`fs.change_directory` checks `\"error\" not in result` — make sure\n+ error paths surface the error key so the harness's working-dir\n+ update is correctly skipped. Uses the actual DOMShell error shape.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: /missing: No such directory\\x1b[0m\"\n+ )\n+ result = backend.cd(\"/missing\")\n+ assert \"error\" in result\n+\n+\n+# ── _is_error helper ─────────────────────────────────────────────────\n+\n+\n+def test_is_error_detects_isError_attribute():\n+ assert backend._is_error(SimpleNamespace(isError=True)) is True\n+ assert backend._is_error(SimpleNamespace(isError=False)) is False\n+\n+\n+def test_is_error_detects_dict_keys():\n+ assert backend._is_error({\"isError\": True}) is True\n+ assert backend._is_error({\"error\": \"boom\"}) is True\n+ assert backend._is_error({\"path\": \"/main\"}) is False\n+\n+\n+def test_is_error_detects_ansi_red_wrapper():\n+ \"\"\"Common DOMShell error shape: ANSI red around a command-prefixed\n+ message. These do NOT start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then ``startswith(\"error\")``\n+ failed every one of these, silently regressing the safety chain\n+ across every wrapper. Catch on the ``\\\\x1b[31m`` red marker\n+ instead.\n+ \"\"\"\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mcd: foo: No such directory\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mls: main: No such directory\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mcd: tab 12345 is outside the session group\\x1b[0m\")\n+ ) is True\n+\n+\n+def test_is_error_detects_explicit_error_prefix_without_ansi():\n+ \"\"\"Fallback: rarer non-coloured errors or pre-stripped input still\n+ detected via ``\"error:\"`` prefix.\n+ \"\"\"\n+ assert backend._is_error(_make_result(\"Error: bad command\")) is True\n+ assert backend._is_error(_make_result(\"ERROR: case insensitive\")) is True\n+\n+\n+def test_is_error_does_not_flag_success_in_other_colors():\n+ \"\"\"Anti-false-positive: only ``\\\\x1b[31m`` (red) signals an error.\n+ Success commonly wraps in ``\\\\x1b[32m`` (green) — must not flag.\n+ \"\"\"\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[32m✓ ok\\x1b[0m\")\n+ ) is False\n+ assert backend._is_error(\n+ _make_result(\"✓ command completed\")\n+ ) is False\n+ assert backend._is_error(\n+ _make_result(\"✓ Focused\\n[lane: 1]\")\n+ ) is False\n+\n+\n+def test_is_error_handles_empty():\n+ assert backend._is_error(_make_result(\"\")) is False\n+\n+\n+def test_is_error_handles_missing_content():\n+ assert backend._is_error(SimpleNamespace()) is False\n+\n+\n+# ── grep: command string and call sequencing ──────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_produces_single_grep_call(mock_call):\n+ \"\"\"Unrooted grep dispatches one ``grep -r <pattern>`` call.\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"Login\")\n+\n+ # session=None when no session is passed (default).\n+ assert mock_call.call_args_list == [call(\"grep -r Login\", False, session=None)]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_uses_recursive_flag(mock_call):\n+ \"\"\"Regression: pre-migration ``domshell_grep`` defaulted to\n+ recursive=True; the unrooted branch must preserve that by passing\n+ ``-r`` so nested matches aren't silently missed.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\")\n+ assert mock_call.call_args.args[0] == \"grep -r Login\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_uses_recursive_flag(mock_call):\n+ \"\"\"Regression: the rooted branch's middle call (the grep itself)\n+ must also pass ``-r``. The 3-call sequence is cd / grep -r / cd-back.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", path=\"main\", session=_make_session())\n+ # grep is the middle of the 3-call sequence.\n+ assert mock_call.call_args_list[1].args[0] == \"grep -r Login\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_emits_three_call_sequence(mock_call):\n+ \"\"\"Rooted grep is THREE separate ``_call_execute`` calls: anchor →\n+ grep → restore. Anchor success is load-bearing (would search the\n+ wrong subtree on cwd drift), so we can't fold this into a single\n+ multi-line continue-on-error call.\n+\n+ Lane sharing across the three calls is preserved via\n+ ``session.domshell_lane_id`` — see round-4 lane-persistence tests.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\", session=sess)\n+\n+ assert mock_call.call_args_list == [\n+ call(\"cd %here%/main\", False, session=sess),\n+ call(\"grep -r Login\", False, session=sess),\n+ call(\"cd %here%\", False, session=sess),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_quotes_path_with_spaces(mock_call):\n+ \"\"\"Absolute paths with whitespace are quoted as `cd '%here%/path with spaces'`.\n+\n+ Upstream-smoked: DOMShell's `cd` accepts the quoted form cleanly.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+\n+ backend.grep(\"Login\", path=\"/path with spaces\", prev=\"/\", session=sess)\n+\n+ # Three-call sequence — quoting applies to the anchor (first call).\n+ assert mock_call.call_args_list == [\n+ call(\"cd '%here%/path with spaces'\", False, session=sess),\n+ call(\"grep -r Login\", False, session=sess),\n+ call(\"cd %here%\", False, session=sess),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_pattern_with_shell_metacharacters_quoted(mock_call):\n+ \"\"\"Patterns with shell metacharacters get quoted (no injection via grep).\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"$(rm -rf /)\")\n+\n+ grep_cmd = mock_call.call_args_list[0].args[0]\n+ # shlex.quote will single-quote the dangerous payload.\n+ assert grep_cmd == \"grep -r '$(rm -rf /)'\"\n+\n+\n+def test_grep_rejects_positional_path():\n+ \"\"\"grep(pattern, path) — positional path raises TypeError.\n+\n+ Pre-migration callers writing ``grep(\"Login\", True)`` to mean\n+ ``use_daemon=True`` must not silently get ``path=True``.\n+ \"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", True) # type: ignore[misc]\n+\n+\n+def test_grep_rejects_positional_use_daemon():\n+ \"\"\"Even the third positional slot is blocked.\"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", \"/main\", \"/\", True) # type: ignore[misc]\n+\n+\n+def test_grep_keyword_use_daemon_still_works():\n+ \"\"\"Keyword call against the new signature still type-checks at call time.\"\"\"\n+ with patch.object(backend, \"_call_execute\", new_callable=AsyncMock) as mock_call:\n+ mock_call.return_value = {}\n+ backend.grep(\"Login\", use_daemon=True)\n+ assert mock_call.call_args_list == [call(\"grep -r Login\", True, session=None)]\n+\n+\n+# ── type_text: focus+type pairing and newline injection guard ─────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_emits_focus_then_type_with_session(mock_call):\n+ \"\"\"type_text issues focus + type as two separate execute calls.\n+\n+ The split is for safety: DOMShell's multi-line splitter continues\n+ past per-line errors, so a single ``focus path\\\\ntype text`` call\n+ would dispatch keys into stale focus if ``focus`` failed. Two calls\n+ with an error check between them prevents that.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\"✓ Focused\\n[lane: 1]\")\n+\n+ backend.type_text(\"search_input\", \"machine learning\", session=sess)\n+\n+ assert mock_call.call_count == 2\n+ # Relative path → no anchor wrap.\n+ assert mock_call.call_args_list[0].args[0] == \"focus search_input\"\n+ assert mock_call.call_args_list[1].args[0] == \"type 'machine learning'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_absolute_path_uses_four_separate_calls(mock_call):\n+ \"\"\"Absolute focus path: anchor → focus → type → restore, all distinct.\n+\n+ type_text is a safety chain, NOT a cleanup-line idiom: it must HALT\n+ on focus failure rather than continue past it. Wrapping focus in a\n+ multi-line ``cd %here%\\\\nfocus\\\\ncd <restore>`` would re-introduce\n+ the continue-on-error trap (the anchor's leading \"✓\" masks the\n+ focus error in the combined response). Split into four separate\n+ _call_execute calls, all sharing the persisted lane via session.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/main\")\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+\n+ backend.type_text(\"/main/input\", \"hello\", session=sess)\n+\n+ assert mock_call.call_count == 4\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"focus main/input\"\n+ assert mock_call.call_args_list[2].args[0] == \"type hello\"\n+ assert mock_call.call_args_list[3].args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_absolute_path_focus_failure_skips_type_and_restores(mock_call):\n+ \"\"\"The Codex P2 safety case: a stale absolute focus path must halt\n+ before type can dispatch keys into whatever was previously focused.\n+ The restore still runs so the lane cwd ends up where the harness\n+ expects.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/main\")\n+ mock_call.side_effect = [\n+ _make_result(\"✓ Entered tab 123\\n[lane: 1]\"), # cd anchor ok\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\"), # focus fails\n+ _make_result(\"✓ Typed\\n[lane: 1]\"), # MUST NOT be reached\n+ _make_result(\"✓\\n[lane: 1]\"), # restore\n+ ]\n+\n+ backend.type_text(\"/main/missing\", \"secret_password\", session=sess)\n+\n+ # Three calls: anchor, focus, restore. Type is skipped because the\n+ # focus error halts the safety chain before keys are dispatched.\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"focus main/missing\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+ # Critically — the \"type secret_password\" command was never sent.\n+ for call_args in mock_call.call_args_list:\n+ assert \"type\" not in call_args.args[0].split(\"\\n\")[0]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_anchor_failure_does_not_attempt_focus(mock_call):\n+ \"\"\"If even the anchor cd fails (e.g. chrome:// not debuggable),\n+ neither focus nor type runs. No restore needed because we never\n+ moved off the original cwd.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+\n+ backend.type_text(\"/some/path\", \"text\", session=sess)\n+\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_relative_path_focus_failure_skips_type(mock_call):\n+ \"\"\"Relative path focus failure: no anchor (no drift to restore), so\n+ just `focus`, then halt. Type MUST NOT run.\n+\n+ The absolute-path equivalent (with anchor + restore) is covered by\n+ test_type_text_absolute_path_focus_failure_skips_type_and_restores.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.side_effect = [\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\"), # focus fails\n+ _make_result(\"✓ Typed\"), # should NOT be reached\n+ ]\n+\n+ result = backend.type_text(\"stale_input\", \"secret_password\", session=sess)\n+\n+ # Only the focus call was made; the focus result was returned.\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"focus stale_input\"\n+ # The focus result is parsed (CLI consumes dicts, not CallToolResult).\n+ assert result == {\n+ \"error\": \"\\x1b[31mfocus: No such element\\x1b[0m\",\n+ \"output\": \"\\x1b[31mfocus: No such element\\x1b[0m\",\n+ }\n+\n+\n+def test_type_text_raises_without_session_in_non_daemon_mode():\n+ \"\"\"Non-daemon mode: the two halves must share a lane via group_id,\n+ which requires a session. Without one, raise.\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.type_text(\n+ \"search_input\", \"text\", use_daemon=False, session=None,\n+ )\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_allows_no_session_in_daemon_mode(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — session\n+ isn't required. Locks in the contract Copilot flagged.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+\n+ # No exception. Relative path → two calls (focus + type).\n+ backend.type_text(\"search_input\", \"hello\", use_daemon=True, session=None)\n+\n+ assert mock_call.call_count == 2\n+ assert mock_call.call_args_list[0].args[0] == \"focus search_input\"\n+ assert mock_call.call_args_list[1].args[0] == \"type hello\"\n+\n+\n+def test_type_text_raises_with_empty_path():\n+ with pytest.raises(ValueError, match=\"input path is required\"):\n+ backend.type_text(\"\", \"text\", session=_make_session())\n+ with pytest.raises(ValueError, match=\"input path is required\"):\n+ backend.type_text(\"/\", \"text\", session=_make_session())\n+\n+\n+def test_type_text_rejects_newline_in_text():\n+ \"\"\"``\\\\n`` in text would inject a new DOMShell command — must raise.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\nline2\")\n+\n+\n+def test_type_text_rejects_carriage_return_in_text():\n+ \"\"\"``\\\\r`` is just as dangerous as ``\\\\n`` for DOMShell's line splitter.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\rline2\")\n+\n+\n+def test_type_text_rejects_newline_in_path():\n+ \"\"\"A newline in the path argument also injects — guard both fields.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"input\\nclick /admin\", \"anything\")\n+\n+\n+# ── grep: newline guard on rooted multi-step path ─────────────────────\n+\n+\n+def test_grep_rejects_newline_in_path():\n+ \"\"\"Rooted grep interpolates path into a multi-line cd/grep/cd — reject newlines.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\\nclick /admin\", prev=\"/\")\n+\n+\n+def test_grep_rejects_newline_in_pattern():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\\nclick /admin\", path=\"/main\", prev=\"/\")\n+\n+\n+def test_grep_rejects_hyphen_prefixed_pattern():\n+ \"\"\"DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ so the grep wrapper can't pass hyphen-prefixed search strings as\n+ patterns. The wrapper raises ValueError with a clear message so\n+ users see the limitation immediately rather than getting DOMShell's\n+ generic Usage reply. Real fix needs upstream parseArgs ``--``\n+ support; tracked upstream. (@yuh-yang R3 blocker 3, Path B.)\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"patterns starting with '-'\"):\n+ backend.grep(\"-disabled\")\n+ with pytest.raises(ValueError, match=\"patterns starting with '-'\"):\n+ backend.grep(\"--content\")\n+\n+\n+def test_grep_rejects_newline_in_prev():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\\nclick /admin\")\n+\n+\n+# ── Centralized newline guard in _q ──────────────────────────────────\n+#\n+# The per-wrapper _assert_single_line calls above cover type_text and\n+# rooted grep with field-named error messages. The newline check inside\n+# _q itself catches the same class of injection for every OTHER wrapper\n+# that flows user input through the quoting layer (open_url, click, cd,\n+# cat, unrooted grep, etc.) — without needing a per-call guard at each\n+# site.\n+\n+\n+def test_q_rejects_line_feeds():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\nbar\")\n+\n+\n+def test_q_rejects_carriage_returns():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\rbar\")\n+\n+\n+def test_q_accepts_normal_strings():\n+ \"\"\"Plain strings pass through to shlex.quote unchanged.\"\"\"\n+ assert backend._q(\"simple\") == \"simple\"\n+ assert backend._q(\"hello world\") == \"'hello world'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_unrooted_grep_pattern_rejects_newlines(mock_call):\n+ \"\"\"The unrooted grep path was not field-guarded — _q catches it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.grep(\"evil\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_open_url_rejects_newlines(mock_call):\n+ \"\"\"open_url has no per-call _assert_single_line — _q must catch it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.open_url(\"https://example.com\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_rejects_newlines(mock_call):\n+ \"\"\"click is covered structurally by _q without a per-call guard.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.click(\"/main/button[0]\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_rejects_newlines(mock_call):\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.cd(\"/main\\nclick /admin\")\n+\n+\n+# ── DOMShell lane persistence across _call_execute calls ─────────────\n+#\n+# DOMShell 2.x assigns a fresh lane (Chrome tab-group) to every new MCP\n+# session. In non-daemon mode each _call_execute opens its own stdio\n+# ClientSession, so without explicit group_id every command would land\n+# in a brand-new lane and lose browser state from the previous call.\n+# The fix: parse the trailing \"[lane: <id>]\" marker DOMShell appends to\n+# each reply, store it on the harness Session, and pass group_id=<id>\n+# on every subsequent call.\n+\n+\n+def _make_session(\n+ working_dir: str = \"/\",\n+ daemon_mode: bool = False,\n+ lane_id=None,\n+):\n+ \"\"\"Build a minimal session fixture compatible with the backend's\n+ ``getattr``-style access (working_dir, daemon_mode, domshell_lane_id).\"\"\"\n+ return SimpleNamespace(\n+ working_dir=working_dir,\n+ daemon_mode=daemon_mode,\n+ domshell_lane_id=lane_id,\n+ )\n+\n+\n+def _make_result(text: str):\n+ \"\"\"Build a fake CallToolResult whose ``content[0].text`` is ``text``.\"\"\"\n+ return SimpleNamespace(content=[SimpleNamespace(text=text)])\n+\n+\n+# ── _extract_lane_id ────────────────────────────────────────────────\n+\n+\n+def test_extract_lane_id_parses_trailing_marker():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: 12345]\")) == \"12345\"\n+\n+\n+def test_extract_lane_id_handles_trailing_whitespace():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: lane-abc]\\n\")) == \"lane-abc\"\n+\n+\n+def test_extract_lane_id_ignores_shared_marker():\n+ \"\"\"`[lane: shared]` is DOMShell's no-isolation sentinel — must not pin to it.\"\"\"\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: shared]\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_when_marker_absent():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_for_empty_text():\n+ assert backend._extract_lane_id(_make_result(\"\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_when_content_missing():\n+ assert backend._extract_lane_id(SimpleNamespace()) is None\n+\n+\n+# ── lane capture + propagation ──────────────────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_first_call_passes_wrapper_signature_and_captures_lane(mock_call):\n+ \"\"\"A session with no stored lane: the wrapper passes (command,\n+ use_daemon, session=sess) into ``_call_execute``; the wire-format\n+ ``group_id`` selection (``\"new\"`` for non-daemon first calls,\n+ ``\"shared\"`` for daemon-mode-no-session) happens inside\n+ ``_call_execute`` itself and is covered by the dedicated\n+ wire-payload tests below. This test only asserts the wrapper-level\n+ call signature plus the ``_capture_lane`` parser hookup.\n+ \"\"\"\n+ sess = Session() # domshell_lane_id starts as None\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 12345]\")\n+\n+ backend.click(\"submit_btn\", session=sess)\n+\n+ # The session= kwarg the wrapper passes is the Session object itself;\n+ # _call_execute is responsible for translating session.domshell_lane_id\n+ # into the wire-format group_id. We only assert the call signature here.\n+ assert mock_call.call_args == call(\"click submit_btn\", False, session=sess)\n+ # _call_execute is mocked, so we exercise _capture_lane directly to\n+ # verify the parser hookup that the real _call_execute would do.\n+ backend._capture_lane(sess, mock_call.return_value)\n+ assert sess.domshell_lane_id == \"12345\"\n+\n+\n+def test_capture_lane_updates_session():\n+ sess = Session()\n+ backend._capture_lane(sess, _make_result(\"✓\\n[lane: lane-XYZ]\"))\n+ assert sess.domshell_lane_id == \"lane-XYZ\"\n+\n+\n+def test_capture_lane_no_op_when_session_is_none():\n+ \"\"\"Direct backend callers without a session must not crash.\"\"\"\n+ backend._capture_lane(None, _make_result(\"✓\\n[lane: 12345]\")) # no exception\n+\n+\n+def test_capture_lane_no_op_when_marker_missing():\n+ sess = Session()\n+ sess.domshell_lane_id = \"preexisting\"\n+ backend._capture_lane(sess, _make_result(\"✓ done\"))\n+ # No marker → don't clobber the previously-captured lane.\n+ assert sess.domshell_lane_id == \"preexisting\"\n+\n+\n+def test_capture_lane_ignores_shared_marker():\n+ sess = Session()\n+ sess.domshell_lane_id = \"preexisting\"\n+ backend._capture_lane(sess, _make_result(\"✓\\n[lane: shared]\"))\n+ assert sess.domshell_lane_id == \"preexisting\"\n+\n+\n+# ── End-to-end: lane reuse on subsequent calls ───────────────────────\n+\n+\n+def test_call_execute_includes_group_id_when_lane_is_set():\n+ \"\"\"When session.domshell_lane_id is set, _call_execute sends it as group_id.\n+\n+ We bypass the stdio_client / ClientSession plumbing entirely by patching\n+ them — what we want to assert is the arguments dict that gets passed to\n+ ``call_tool``.\n+ \"\"\"\n+ sess = Session()\n+ sess.domshell_lane_id = \"lane-7\"\n+\n+ fake_tool = AsyncMock(return_value=_make_result(\"✓\\n[lane: lane-7]\"))\n+\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.__aenter__.return_value = fake_mcp_session\n+ fake_mcp_session.__aexit__.return_value = None\n+ fake_mcp_session.initialize = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ fake_stdio = AsyncMock()\n+ fake_stdio.__aenter__.return_value = (object(), object())\n+ fake_stdio.__aexit__.return_value = None\n+\n+ with patch.object(backend, \"stdio_client\", return_value=fake_stdio), \\\n+ patch.object(backend, \"ClientSession\", return_value=fake_mcp_session), \\\n+ patch.object(backend, \"_build_server_args\", return_value=[]):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", session=sess))\n+\n+ name, arguments = fake_tool.call_args.args\n+ assert name == \"domshell_execute\"\n+ assert arguments == {\"command\": \"ls /\", \"group_id\": \"lane-7\"}\n+\n+\n+def test_call_execute_passes_group_id_new_when_lane_is_none():\n+ \"\"\"First-call shape: no stored lane → ``group_id=\"new\"``; DOMShell\n+ creates an isolated lane and returns the id, which we capture for\n+ next time.\n+\n+ Migration note (PR #308 follow-up to DOMShell 2.0.2): we used to omit\n+ ``group_id`` on the first call entirely, which DOMShell 2.x mapped\n+ to a fresh lane silently. 2.0.2 deprecated that path — omitting now\n+ emits a [DEPRECATION] warning on every reply (will be a hard error\n+ in 3.0.0). Passing ``\"new\"`` makes the intent explicit and silences\n+ the warning.\n+ \"\"\"\n+ sess = Session() # lane is None\n+ fake_tool = AsyncMock(return_value=_make_result(\"✓\\n[lane: brand-new]\"))\n+\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.__aenter__.return_value = fake_mcp_session\n+ fake_mcp_session.__aexit__.return_value = None\n+ fake_mcp_session.initialize = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ fake_stdio = AsyncMock()\n+ fake_stdio.__aenter__.return_value = (object(), object())\n+ fake_stdio.__aexit__.return_value = None\n+\n+ with patch.object(backend, \"stdio_client\", return_value=fake_stdio), \\\n+ patch.object(backend, \"ClientSession\", return_value=fake_mcp_session), \\\n+ patch.object(backend, \"_build_server_args\", return_value=[]):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", session=sess))\n+\n+ arguments = fake_tool.call_args.args[1]\n+ assert arguments.get(\"group_id\") == \"new\"\n+ # The auto-assigned lane gets captured for next time.\n+ assert sess.domshell_lane_id == \"brand-new\"\n+\n+\n+def test_call_execute_daemon_no_session_first_call_passes_new_and_captures_lane():\n+ \"\"\"Daemon mode + no session, first call: passes ``group_id=\"new\"``\n+ and captures the lane id from the response into the module-level\n+ ``_daemon_lane_id`` for subsequent calls. Replaces the previous\n+ ``\"shared\"`` behavior (commit 99d1182) per @yuh-yang R3 blocker 2.\n+\n+ The R2 \"shared\" branch claimed per-connection-default stickiness\n+ that holds when the persistent daemon connection is alive but\n+ breaks in the fall-back spawn path (each call gets its own\n+ per-MCP-session default lane). The captured-id approach works\n+ consistently across both paths because Chrome tab-group ids\n+ persist at the browser level, regardless of MCP session.\n+ \"\"\"\n+ # Reset module state (other tests may have populated it).\n+ backend._daemon_lane_id = None\n+\n+ try:\n+ fake_tool = AsyncMock(\n+ return_value=_make_result(\"✓\\n[lane: daemon-captured-99]\")\n+ )\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ with patch.object(backend, \"_daemon_session\", fake_mcp_session):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", use_daemon=True, session=None))\n+\n+ name, arguments = fake_tool.call_args.args\n+ assert name == \"domshell_execute\"\n+ assert arguments.get(\"group_id\") == \"new\"\n+ assert backend._daemon_lane_id == \"daemon-captured-99\"\n+ finally:\n+ backend._daemon_lane_id = None\n+\n+\n+def test_call_execute_daemon_no_session_subsequent_calls_reuse_captured_lane():\n+ \"\"\"Once ``_daemon_lane_id`` is set, daemon-no-session calls pass\n+ that id as ``group_id`` instead of ``\"new\"`` — preserves browser\n+ state across calls regardless of whether the daemon's stdio is\n+ alive or whether we've fallen back to fresh spawns per call.\n+ Capture stays stable; no clobber on subsequent calls.\n+ \"\"\"\n+ backend._daemon_lane_id = \"preexisting-77\"\n+\n+ try:\n+ fake_tool = AsyncMock(\n+ return_value=_make_result(\"✓\\n[lane: preexisting-77]\")\n+ )\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ with patch.object(backend, \"_daemon_session\", fake_mcp_session):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", use_daemon=True, session=None))\n+\n+ name, arguments = fake_tool.call_args.args\n+ assert arguments.get(\"group_id\") == \"preexisting-77\"\n+ # Capture stays the same — no clobber on subsequent calls.\n+ assert backend._daemon_lane_id == \"preexisting-77\"\n+ finally:\n+ backend._daemon_lane_id = None\n+\n+\n+def test_distinct_sessions_have_isolated_lanes():\n+ \"\"\"Two sessions track lanes independently — no cross-contamination.\"\"\"\n+ s1 = Session()\n+ s2 = Session()\n+ backend._capture_lane(s1, _make_result(\"✓\\n[lane: lane-A]\"))\n+ backend._capture_lane(s2, _make_result(\"✓\\n[lane: lane-B]\"))\n+ assert s1.domshell_lane_id == \"lane-A\"\n+ assert s2.domshell_lane_id == \"lane-B\"\n+\n+\n+# ── Keyword-only enforcement on session= ─────────────────────────────\n+#\n+# Only ``session`` is keyword-only; ``use_daemon`` stays positional so\n+# pre-2.0.0 callers like ``ls(\"/\", True)`` keep working. ``grep`` is a\n+# deliberate exception (fully keyword-only after the round-1 review).\n+\n+\n+def test_session_is_keyword_only_on_click():\n+ \"\"\"Trailing positional `None` is interpreted as a 3rd positional arg\n+ that the wrapper doesn't accept — must raise TypeError.\"\"\"\n+ with pytest.raises(TypeError):\n+ backend.click(\"submit_btn\", False, None) # type: ignore[misc]\n+\n+\n+def test_session_is_keyword_only_on_ls():\n+ with pytest.raises(TypeError):\n+ backend.ls(\"/\", False, None) # type: ignore[misc]\n+\n+\n+def test_session_is_keyword_only_on_type_text():\n+ with pytest.raises(TypeError):\n+ backend.type_text(\"input\", \"hello\", False, None) # type: ignore[misc]\n+\n+\n+def test_session_is_keyword_only_on_open_url():\n+ with pytest.raises(TypeError):\n+ backend.open_url(\"https://example.com\", False, None) # type: ignore[misc]\n+\n+\n+# ── Positional `use_daemon` stays valid ──────────────────────────────\n+#\n+# These guard against accidentally pulling ``use_daemon`` behind the ``*``\n+# in the future. Pre-2.0.0 calls written as ``ls(\"/\", True)`` must not\n+# regress to ``TypeError``.\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_ls(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/\", True) # use_daemon=True positionally\n+ # Absolute `/` with no session → 3-call sequence, use_daemon=True\n+ # flows through all three calls.\n+ assert mock_call.call_args_list == [\n+ call(\"cd %here%\", True, session=None),\n+ call(\"ls\", True, session=None),\n+ call(\"cd %here%\", True, session=None),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_click(mock_call):\n+ mock_call.return_value = {}\n+ backend.click(\"submit_btn\", True)\n+ assert mock_call.call_args == call(\"click submit_btn\", True, session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_reload(mock_call):\n+ mock_call.return_value = {}\n+ backend.reload(True)\n+ assert mock_call.call_args == call(\"refresh\", True, session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_type_text(mock_call):\n+ \"\"\"Positional ``use_daemon`` flows through both halves of the split.\n+\n+ type_text now requires a session, so pass one explicitly.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+ backend.type_text(\"input\", \"hello\", True, session=sess)\n+ # Two calls (focus then type), both with use_daemon=True positionally.\n+ assert mock_call.call_args_list == [\n+ call(\"focus input\", True, session=sess),\n+ call(\"type hello\", True, session=sess),\n+ ]\n"},{"comment":"The conditional `if path else \"ls\"` is effectively unreachable: `path` defaults to `\"/\"` and there is no documented contract that callers may pass an empty string (and an empty `path` would have a different DOMShell semantic — `ls` with no arg lists the server cwd, while `ls /` lists root). Either drop the branch and always emit `f\"ls {_q(path)}\"`, or change the default to `\"\"` and document that the empty-string case lists the lane's cwd. As written, this is dead code that hides intent.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -239,16 +354,17 @@ def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n >>> ls(\"/\")\n {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n+ command = f\"ls {_q(path)}\" if path else \"ls\"\n+ return asyncio.run(_call_execute(command, use_daemon, session=session))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The error message embeds the full offending argument via `{arg!r}`. Because `_q` is the central guard against command injection, the rejected value can be arbitrarily large (e.g. a multi-line paste) and may be propagated into logs/telemetry verbatim. Consider truncating the echoed value (e.g. first ~80 chars + length) so error output stays bounded and avoids inadvertently logging large untrusted payloads.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +117,103 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got: {arg!r}\"\n+ )","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Preserve positional daemon arguments**\n\nAdding `*` here changes the public sync-wrapper API even though this module documents it as unchanged: downstream Python callers that previously used valid calls such as `ls('/', True)`, `click('/main/button', True)`, or `reload(True)` to enable daemon mode now get `TypeError` before any DOMShell call runs. The new `session` parameter can be keyword-only without forcing the existing `use_daemon` argument to become keyword-only across these wrappers.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,14 +333,19 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", *, use_daemon: bool = False, session: Any = None) -> dict:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Map harness absolute paths before executing**\n\nWhen the normal flow opens a page and then runs `fs ls` (or the documented `fs ls /` / `fs cd /main`), the harness passes its internal absolute DOM path straight through as `ls /` or `cd /main`. DOMShell 2 treats `~`/`/` as the browser root, not the current tab's AX-tree root, so these commands list windows/tabs or fail instead of exploring page elements. Translate the harness's `/` and `/main/...` paths to DOMShell's current-tab-relative paths before building the command string.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -239,16 +358,16 @@ def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n >>> ls(\"/\")\n {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(f\"ls {_q(path)}\", use_daemon, session=session))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Don't type after a failed focus command**\n\nIf `act type` is called with a stale or mistyped path while another input is focused, DOMShell's multi-line execute semantics continue after per-line errors, so the `type` line still runs even when `focus` failed and can enter text into the wrong element. Run `focus` and `type` as separate execute calls and only issue `type` after verifying focus succeeded, or use an atomic DOMShell command that fails as a unit.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -391,24 +549,17 @@ def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n \n Returns:\n Dict with action result\n- \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n- )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n+ \"\"\"\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+ command = f\"focus {_q(path)}\\ntype {_q(text)}\"","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"This row is inconsistent with the implementation. `type_text` deliberately issues `focus` and `type` as **two separate `_call_execute` calls** (with an `_is_error` check in between) to avoid the unsafe focus/type race described in the wrapper's own docstring — it is not delivered as a single multi-line `focus\\\\ntype` command. Consider rewording this entry, e.g. `focus <path>` then (on success) `type <text>` (two calls), to match the actual wire behaviour and to avoid implying the same continue-on-error semantics that `fs grep <pat> <path>` uses.","path":"browser/agent-harness/HARNESS.md","hunk":"@@ -38,29 +38,41 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n ### Installation\n \n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+# Verify DOMShell is available (2.0.0 or newer required)\n+npx @apireno/domshell@2.0.0 --version\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+**Minimum version: `@apireno/domshell@2.0.0`.** DOMShell 2.0.0 (May 2026)\n+consolidated the MCP tool surface from 38 per-command tools to a single\n+`domshell_execute` tool. The harness targets this consolidated tool, so no\n+opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.0+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands:\n+\n+| CLI Command | Command string sent to `domshell_execute` |\n+|-------------|--------------------------------------------|\n+| `fs ls <path>` | `ls <path>` |\n+| `fs cd <path>` | `cd <path>` |\n+| `fs cat <path>` | `cat <path>` |\n+| `fs grep <pat>` | `grep <pat>` |\n+| `fs grep <pat> <path>` | `cd <path>\\ngrep <pat>\\ncd <prev>` (single call) |\n+| `act click <path>` | `click <path>` |\n+| `act type <path> <text>` | `focus <path>\\ntype <text>` (single call) |","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/HARNESS.md b/browser/agent-harness/HARNESS.md\nindex 7275a41a5a..2cd1ade02a 100644\n--- a/browser/agent-harness/HARNESS.md\n+++ b/browser/agent-harness/HARNESS.md\n@@ -37,30 +37,61 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"new\"` to declare lane intent explicitly on the first call of\n+each session and reuses the captured lane id on subsequent calls (silences\n+the deprecation warning that 2.0.2 added for omitted `group_id`; will\n+become a hard error in DOMShell 3.0.0). For direct daemon-mode callers\n+without a harness `Session`, the same scheme runs at module level — the\n+first call captures a lane id into `_daemon_lane_id` and subsequent calls\n+reuse it, preserving browser state across daemon-mode no-session calls\n+(see `domshell_backend.py`'s `_daemon_lane_id` declaration for the\n+stale-lane failure mode).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |\n+| `page open <url>` | `open <url>` |\n+| `page reload` | `refresh` |\n+| `page back` | `back` |\n+| `page forward` | `forward` |\n+\n+`<restore>` resolves to `cd %here%/<harness-working-dir>` (or `cd %here%`\n+when the harness is at the tab root) so the lane's cwd ends up where\n+the harness expects.\n \n ## Key Design Decisions\n \n"},{"comment":"When `session is None` (e.g. direct backend callers, or `act type` paths that ever forget to pass `session=`), the `focus` and `type` calls run in two independent stdio MCP sessions with no `group_id` linkage — DOMShell will auto-assign a fresh lane to each, so the `type` call lands in a different lane than the `focus` and the focus state is lost (the comment on lines 652–656 only holds when a session pins the lane). Consider either (a) requiring `session` to be non-`None` for `type_text` (raise `ValueError` up-front), or (b) capturing the lane from `focus_result` into a transient local session-like object when the caller passed `None`, so the second call inherits the same `group_id`.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -335,80 +560,108 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\n >>> open_url(\"https://example.com\")\n {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ return asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+ translated_path = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an element name is required — cannot focus the tab root.\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- return asyncio.run(_focus_and_type())\n+ # Relies on DOMShell serializing commands within a lane: the `type`\n+ # call below cannot be preempted by another agent's `focus` on the\n+ # same lane between these two _call_execute boundaries. If that\n+ # contract ever changes upstream, this needs to revert to a single\n+ # multi-line call with an alternative safety story.\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ return focus_result # don't type — focus didn't land\n+ return asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_q` and `_assert_single_line` now both reject `\\\\n`/`\\\\r` with very similar error text but slightly different wording, and several wrappers (`grep`, `type_text`) call `_assert_single_line` immediately before `_q`, which is redundant — `_q` would raise on the same input one line later. Consider having `_assert_single_line` be the single source of truth (called from inside `_q`, or called by wrappers that want field-named errors with `_q` no longer duplicating the check), so future wrappers can't drift between two subtly different guards. Optional.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +117,156 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_translate_path` only strips a single leading `/`, so a harness path like `\\\"//main\\\"` (which `fs.change_directory` can produce via the `rstrip(\\\"/\\\") + \\\"/\\\" + path` join when `path` already starts with `/`) becomes `\\\"/main\\\"` after translation and is then shell-quoted and shipped to DOMShell as an absolute browser-root path — exactly the bug the `~/`-vs-`/` translation is meant to prevent. Consider using `harness_path.lstrip(\\\"/\\\")` (and treating an all-slash input as the lane-cwd sentinel) so any number of leading slashes collapses to a lane-relative path.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +117,156 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> str:\n+ \"\"\"Translate a harness DOM path to a DOMShell command path.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``~/`` (and bare ``/``) as the BROWSER root — windows and tabs.\n+ Sending ``ls /`` verbatim would list tabs, not page elements. Strip\n+ the leading ``/`` so harness ``/main`` becomes DOMShell ``main``\n+ (relative to the lane's cwd, which IS the focused tab's AX root once\n+ ``page open`` has put the lane inside the tab).\n+\n+ - ``\"\"`` and ``\"/\"`` → ``\"\"`` (signal: operate on lane cwd; the\n+ wrappers turn this into a bare command, e.g. ``ls`` or ``cd %here%``).\n+ - ``\"/main\"`` → ``\"main\"``\n+ - ``\"/main/article\"`` → ``\"main/article\"``\n+ - ``\"main\"``, ``\"..\"``, ``\".\"`` → passed through unchanged.\n+ \"\"\"\n+ if not harness_path or harness_path == \"/\":\n+ return \"\"\n+ if harness_path.startswith(\"/\"):\n+ return harness_path[1:]\n+ return harness_path","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Root absolute harness paths before stripping the slash**\n\nWhen the lane cwd is no longer the tab root (for example `fs cd /main` pins the DOMShell lane at `/main`, then `fs ls` uses `session.working_dir == \"/main\"`), stripping the absolute harness path to `main` makes DOMShell resolve it relative to the current cwd and target `/main/main` instead of `/main`. This affects ordinary absolute operations after any `cd`; absolute harness paths need to be executed from the tab root (e.g. via `%here%`) or otherwise encoded as root-relative before being sent to DOMShell.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +117,156 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> str:\n+ \"\"\"Translate a harness DOM path to a DOMShell command path.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``~/`` (and bare ``/``) as the BROWSER root — windows and tabs.\n+ Sending ``ls /`` verbatim would list tabs, not page elements. Strip\n+ the leading ``/`` so harness ``/main`` becomes DOMShell ``main``\n+ (relative to the lane's cwd, which IS the focused tab's AX root once\n+ ``page open`` has put the lane inside the tab).\n+\n+ - ``\"\"`` and ``\"/\"`` → ``\"\"`` (signal: operate on lane cwd; the\n+ wrappers turn this into a bare command, e.g. ``ls`` or ``cd %here%``).\n+ - ``\"/main\"`` → ``\"main\"``\n+ - ``\"/main/article\"`` → ``\"main/article\"``\n+ - ``\"main\"``, ``\"..\"``, ``\".\"`` → passed through unchanged.\n+ \"\"\"\n+ if not harness_path or harness_path == \"/\":\n+ return \"\"\n+ if harness_path.startswith(\"/\"):\n+ return harness_path[1:]","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Preserve focus for direct type_text callers**\n\nFor public callers that use `type_text(...)` without passing a harness `Session` in non-daemon mode, this focus call and the later `type` call open separate MCP sessions/lanes, and the lane from `focus` is not captured because `session` is `None`. That regresses the previous direct-wrapper behavior where focus and type shared one MCP session, so the text can be sent in a fresh lane with no focused element; create a temporary lane/session for this path or keep the two commands on one MCP session.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -335,80 +560,108 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\n >>> open_url(\"https://example.com\")\n {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ return asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+ translated_path = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an element name is required — cannot focus the tab root.\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- return asyncio.run(_focus_and_type())\n+ # Relies on DOMShell serializing commands within a lane: the `type`\n+ # call below cannot be preempted by another agent's `focus` on the\n+ # same lane between these two _call_execute boundaries. If that\n+ # contract ever changes upstream, this needs to revert to a single\n+ # multi-line call with an alternative safety story.\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Detect errors inside wrapped absolute focus**\n\nFor absolute paths, the focus step is still wrapped as a multi-line `cd …\\nfocus …\\ncd …` command. In the stale absolute-path case (for example `act type /main/missing secret`), the leading `cd` and trailing restore can succeed even though the middle `focus` fails; `_is_error` only catches `isError` or text that starts with `error`, so this can miss the focus failure and proceed to the following `type` call into whatever element was already focused. Fresh evidence after the earlier focus-safety comment is that the new split still keeps absolute focus inside a multi-line wrapper.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -335,80 +673,127 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\n >>> open_url(\"https://example.com\")\n {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ return asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # A session is required: the focus and type halves split across two\n+ # _call_execute calls, and without `session.domshell_lane_id` the\n+ # second call would land in a different DOMShell lane and miss the\n+ # focus state from the first.\n+ if session is None:\n+ raise ValueError(\n+ \"type_text: a session argument is required so the focus and type \"\n+ \"calls share a DOMShell lane. Otherwise the focus state from the \"\n+ \"first call would not apply to the second.\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # Relies on DOMShell serializing commands within a lane: the `type`\n+ # call below cannot be preempted by another agent's `focus` on the\n+ # same lane between these two _call_execute boundaries. If that\n+ # contract ever changes upstream, this needs to revert to a single\n+ # multi-line call with an alternative safety story.\n+ if is_absolute:\n+ # Anchor + focus + restore as one multi-line call, so the focus\n+ # lands against the tab root regardless of lane cwd drift.\n+ focus_cmd = _wrap_absolute(f\"focus {_q(translated_path)}\", session)","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"Making `session` mandatory for `type_text` is a behavioral breaking change relative to the pre-migration signature (`type_text(path, text, use_daemon=False)`), and the rationale (lane sharing) doesn't actually apply when `use_daemon=True` — in daemon mode both halves go through the same persistent `_daemon_session` and would share state without an explicit `group_id`. Consider only requiring `session` for the non-daemon path (e.g., `if session is None and not use_daemon:`), or document this in the wrapper's `Raises:` as an unconditional requirement and call it out in the PR/HARNESS notes since callers programmatically using the backend directly will now get a `ValueError` instead of working as before.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -335,80 +694,156 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\n >>> open_url(\"https://example.com\")\n {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ return asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # A session is required: the focus and type halves split across two\n+ # _call_execute calls, and without `session.domshell_lane_id` the\n+ # second call would land in a different DOMShell lane and miss the\n+ # focus state from the first.\n+ if session is None:\n+ raise ValueError(\n+ \"type_text: a session argument is required so the focus and type \"\n+ \"calls share a DOMShell lane. Otherwise the focus state from the \"\n+ \"first call would not apply to the second.\"\n )","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"This docstring example hard-codes `v2.0.0`, but `is_available()` returns whichever version `npx @apireno/domshell --version` reports at runtime, which may be `>=2.0.0`. Consider either using an ellipsis (e.g. `(True, \"DOMShell vX.Y.Z is available\")`) or wording it as \"v2.0.0 or later\" so the example doesn't suggest the function pins to that specific version.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -78,7 +85,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell v2.0.0 is available\")","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The daemon-failure path now swallows the exception entirely with no logging, so an operator debugging why the daemon keeps dying and respawning will have no record of the underlying error (the previous `as e` was unused but at least left the value available). Consider logging the exception (e.g. `logging.warning(\"DOMShell daemon call failed, respawning: %s\", e)`) before falling back so silent daemon thrash is diagnosable.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -130,12 +372,26 @@ async def _call_tool(\n \"\"\"\n global _daemon_session, _daemon_read, _daemon_write\n \n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Reuse the previously-captured DOMShell lane so this call lands in the\n+ # same Chrome tab-group as the prior commands in this session. Without\n+ # this, every fresh stdio ClientSession would be assigned a brand-new\n+ # lane and `page open` / `fs ls` etc. would run in disjoint browser\n+ # state. The very first call leaves group_id unset so DOMShell\n+ # auto-assigns; _capture_lane stores that id on the session for the\n+ # next call.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+\n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n return result\n- except Exception as e:\n+ except Exception:\n # Daemon died, fall back to spawning new server\n await _stop_daemon()","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"Each `asyncio.run` call tears down and rebuilds an event loop, and in non-daemon mode each `_call_execute` also opens a fresh stdio MCP session/process — so the absolute-path branch of `type_text` now spawns up to four DOMShell server processes per call (anchor, focus, type, restore) where the prior implementation used one. This is intentional for the safety split, but consider either (a) refactoring into a single `async def` driver that runs the four steps under one `asyncio.run` and one shared `ClientSession`, or (b) documenting the per-call overhead so users aren't surprised by the latency increase on absolute-path `act type` calls.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -335,80 +694,156 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\n >>> open_url(\"https://example.com\")\n {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ return asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with navigation result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ return asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # A session is required: the focus and type halves split across two\n+ # _call_execute calls, and without `session.domshell_lane_id` the\n+ # second call would land in a different DOMShell lane and miss the\n+ # focus state from the first.\n+ if session is None:\n+ raise ValueError(\n+ \"type_text: a session argument is required so the focus and type \"\n+ \"calls share a DOMShell lane. Otherwise the focus state from the \"\n+ \"first call would not apply to the second.\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ f\"cd {_here_path('')}\", use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return anchor_result\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return focus_result\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The lane marker contract (trailing `[lane: <id>]` line, `shared` sentinel meaning \"no isolation\") is load-bearing for cross-call state in non-daemon mode but is parsed entirely from string output of a third-party tool. Consider adding a brief comment linking to the DOMShell 2.x docs / release notes where this format is specified, so a future DOMShell change to the marker format (e.g. `[group: ...]` or JSON) leaves a clear trail to the affected code.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +117,252 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Reuse MCP sessions to avoid orphan DOMShell lanes**\n\nIn the non-daemon path this still creates and initializes a fresh MCP client for every wrapper call. DOMShell 2's server creates an isolated lane for each MCP client and documents that disconnected clients leave their lane open; when `session.domshell_lane_id` is already set, the command is then routed to the old lane via `group_id`, leaving the newly-created default lane unused after every `fs ls`, `act click`, etc. Keep a `ClientSession` alive for the harness session or explicitly close the throwaway lane before disconnecting.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -147,9 +403,12 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Parse execute replies before returning to CLI**\n\nWhen DOMShell 2 returns a `CallToolResult` from `domshell_execute` (this module's own lane parser reads `result.content`), this wrapper returns that object unchanged. The non-JSON CLI still expects the old structured dicts, e.g. `fs ls` immediately calls `result.get(\"entries\", [])` in `browser_cli.py`, and `fs grep` does the same for matches, so ordinary `cli-anything-browser fs ls` / `fs grep` now raises `AttributeError` instead of printing results. Please parse the execute reply back into the previous dict shape or update the CLI to handle `CallToolResult`.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -239,16 +518,25 @@ def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n >>> ls(\"/\")\n {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ # `ls /main`: cd to %here%/main, run bare ls, restore.\n+ # `ls /`: cd to %here%, run bare ls, restore.\n+ command = _wrap_absolute(\"ls\", session, deeper=translated)\n+ elif translated:\n+ command = f\"ls {_q(translated)}\"\n+ else:\n+ command = \"ls\"\n+ return asyncio.run(_call_execute(command, use_daemon, session=session))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Stop rooted grep after a failed cd**\n\nFor a rooted search whose target path does not exist, DOMShell's documented multi-line behavior continues after per-line errors, so `cd %here%/missing` can fail and the following `grep` still runs in the previous cwd. In a case like `fs grep Login /missing` from `/main`, this can return matches from `/main` instead of reporting that `/missing` was invalid, corrupting search results; the pre-migration code explicitly checked the `cd` result before grepping. The rooted grep path needs an abort-on-cd-failure sequence in one shared lane/session or another DOMShell command form that prevents the grep from running after a failed `cd`.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -294,21 +628,52 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\n Example:\n >>> grep(\"Login\")\n {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\", path=\"/main\")\n+ {\"matches\": [\"/main/button[0]\"]}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n- ))\n- return result\n-\n+ _assert_single_line(\"pattern\", pattern)\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ return asyncio.run(\n+ _call_execute(f\"grep {_q(pattern)}\", use_daemon, session=session)\n+ )\n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"prev\", prev)\n+\n+ if path_abs:\n+ # Absolute path: anchor at `%here%/<target>`, grep, restore to the\n+ # harness's tracked working_dir (so the lane cwd doesn't drift).\n+ # The `%here%/<target>` token is quoted as a single unit by\n+ # `_here_path` — survives whitespace / shell metachars cleanly.\n+ cd_line = f\"cd {_here_path(translated_path)}\"\n+ restore = _restore_cwd_cmd(session)\n+ else:\n+ # Relative path: lane cwd is the right reference. `prev` defaults\n+ # to \"/\" — for relative grep we just go back to whatever caller\n+ # asked, shell-quoted (or `%here%/...` for absolute prev).\n+ translated_prev, prev_abs = _translate_path(prev)\n+ cd_line = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore = f\"cd {_here_path(translated_prev)}\"\n+ else:\n+ restore = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else f\"cd {_here_path('')}\"\n+ )\n+ command = f\"{cd_line}\\ngrep {_q(pattern)}\\n{restore}\"","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The docstring example is now misleading. After the migration, `ls()` returns `{\"entries\": [...], \"raw\": text}` with each entry shaped as `{\"name\": <line>, \"role\": \"\", \"path\": <line>}` (per `_parse_execute_result`). It does not contain a top-level `\"path\"` key and `role` is always empty. Consider updating the example to reflect the actual return shape so callers don't write code against the old contract.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -239,16 +564,41 @@ def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n >>> ls(\"/\")\n {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The example return value no longer matches reality — `cd` now returns `{\"output\": text}` (or `{\"error\": ..., \"output\": ...}` on failure) via `_parse_execute_result(..., \"cd\")`, with no `\"path\"` or `\"element\"` keys. Note that `fs.change_directory` does `result.get(\"path\", path)`, which now always falls back to the input `path`; document this behavior so consumers understand the contract.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -257,16 +607,29 @@ def cd(path: str, use_daemon: bool = False) -> dict:\n >>> cd(\"/main/div[0]\")\n {\"path\": \"/main/div[0]\", \"element\": {...}}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The example return is no longer accurate — `open_url` returns `{\"output\": text}` from `_parse_execute_result(..., \"open\")`, with no `\"url\"` or `\"status\"` keys. This is particularly relevant because `core/page.go_back`/`go_forward` guard their `session.set_url(...)` step on `\"url\" in result`, so that step is now effectively never taken. The internal `_parse_execute_result` docstring acknowledges this as intended, but the public `open_url`/`back`/`forward` docstrings still advertise the old shape; update them so callers know `url` won't be present.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -335,80 +807,172 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\n >>> open_url(\"https://example.com\")\n {\"url\": \"https://example.com\", \"status\": \"loaded\"}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The prose says \"2.0.0 or newer required\" but the command pins exactly to `@2.0.0`, which will block users with newer 2.x releases from verifying with the documented command. Consider either using `@apireno/domshell@^2.0.0` / `@apireno/domshell` (latest) to match the \"or newer\" wording, or removing the version pin from this verification command entirely.","path":"browser/agent-harness/HARNESS.md","hunk":"@@ -38,29 +38,48 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n ### Installation\n \n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+# Verify DOMShell is available (2.0.0 or newer required)\n+npx @apireno/domshell@2.0.0 --version","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/HARNESS.md b/browser/agent-harness/HARNESS.md\nindex 7275a41a5a..2cd1ade02a 100644\n--- a/browser/agent-harness/HARNESS.md\n+++ b/browser/agent-harness/HARNESS.md\n@@ -37,30 +37,61 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"new\"` to declare lane intent explicitly on the first call of\n+each session and reuses the captured lane id on subsequent calls (silences\n+the deprecation warning that 2.0.2 added for omitted `group_id`; will\n+become a hard error in DOMShell 3.0.0). For direct daemon-mode callers\n+without a harness `Session`, the same scheme runs at module level — the\n+first call captures a lane id into `_daemon_lane_id` and subsequent calls\n+reuse it, preserving browser state across daemon-mode no-session calls\n+(see `domshell_backend.py`'s `_daemon_lane_id` declaration for the\n+stale-lane failure mode).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |\n+| `page open <url>` | `open <url>` |\n+| `page reload` | `refresh` |\n+| `page back` | `back` |\n+| `page forward` | `forward` |\n+\n+`<restore>` resolves to `cd %here%/<harness-working-dir>` (or `cd %here%`\n+when the harness is at the tab root) so the lane's cwd ends up where\n+the harness expects.\n \n ## Key Design Decisions\n \n"},{"comment":"The `_assert_single_line(\"path\", path)` check on line 721 is unreachable in practice: `_translate_path(path)` on line 713 already raises `ValueError` with a \"newline\" message if `path` contains `\\n` or `\\r`, so the field-named error message intended here never fires. Either move the `_assert_single_line(\"path\", path)` ahead of `_translate_path` (so it can produce the more specific error) or drop it as dead defense-in-depth.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -294,21 +706,56 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\n Example:\n >>> grep(\"Login\")\n {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\", path=\"/main\")\n+ {\"matches\": [\"/main/button[0]\"]}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The anchor/check/op/restore pattern is duplicated almost verbatim across `ls`, `cat`, `click`, and `grep` (and a 4-step variant in `type_text`). Extracting a single helper like `_run_with_anchor(op_cmd, *, session, use_daemon, parse_as)` that performs the anchor, error short-circuit, op, and best-effort restore in one place would remove ~60 lines of repetition and ensure that any future fix (e.g. capturing the restore error for logging) lands consistently. Optional, but recommended as a follow-up.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -239,16 +564,41 @@ def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n >>> ls(\"/\")\n {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Detect command-prefixed DOMShell errors**\n\nDOMShell shell failures are not always prefixed with `Error:`; the upstream command examples include failures like `cd: tab ... is outside the session group`. When a stale absolute path returns `cd: no such path` (or `focus: ...`) without `isError`, this predicate treats it as success, so the split-and-check wrappers proceed to `ls`/`grep`/`click` in the previous cwd instead of aborting. Please recognize DOMShell’s command-prefixed error lines here before using this helper to gate safety-sensitive follow-up commands.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,304 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Best-effort check that a ``domshell_execute`` result represents an error.\n+\n+ Inspects ``isError`` if the MCP SDK populated it, then ``isError`` /\n+ ``error`` keys on dict-shaped test fixtures, and finally scans the\n+ concatenated text content for a leading \"error\" — with ANSI escape\n+ sequences stripped first, since DOMShell colours error lines red\n+ (``\\\\x1b[31mError: ...\\\\x1b[0m``). Robust to the raw\n+ ``CallToolResult`` and to ``SimpleNamespace(content=[...])`` test\n+ fixtures.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\"):\n+ return True\n+ if \"error\" in result:\n+ return True\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ text = _ANSI_CSI_RE.sub(\"\", text)\n+ return text.strip().lower().startswith(\"error\")","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Preserve URLs for history navigation**\n\nFor `back` and `forward`, returning only `{\"output\": text}` leaves `page.go_back()` / `page.go_forward()` unable to update `session.current_url`, because those functions only call `session.set_url(...)` when the backend result contains a `url` key. After a successful browser back/forward, `page info` and any code using the session URL will still report the previous URL even though the tab has navigated; parse the returned URL (or otherwise include it) for these navigation commands.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,327 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ # cd / cat / click / focus / type / open / refresh / back / forward\n+ # all funnel through the CLI's generic dict pretty-printer; an\n+ # ``{\"output\": text}`` shape is enough.\n+ return {\"output\": text}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Share a lane for direct absolute wrapper calls**\n\nWhen public callers use an absolute path without a harness `session` in non-daemon mode, this split-and-check sequence does not actually share DOMShell state: `_call_execute` only forwards/captures `group_id` through `session`, so `backend.ls(\"/main\")` runs `cd %here%/main` in one fresh MCP client/lane and the bare `ls` in another. Fresh evidence after the earlier lane comments is that the CLI now passes `session`, but these public wrappers still default to `session=None`; use a temporary session/single MCP session or reject this mode for absolute split calls.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,50 +566,114 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\")\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The docstring example shows `ls(\"/main\")` with no `session=` argument, but the new implementation routes absolute paths through `_require_session_for_split_check`, which raises `ValueError` when `session is None and not use_daemon`. Following the example verbatim will fail. Update the example to pass `session=...` (or `use_daemon=True`), and apply the same fix to the `cat(\"/main/button[0]\")`, `click(\"/main/button[0]\")`, and `grep(\"Login\", path=\"/main\")` examples in this file — all four advertise a usage pattern the new validation rejects.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,50 +613,115 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\")\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"This text-concatenation loop duplicates `_extract_text` (defined a few lines below). Consider calling `_extract_text(result)` here so there is a single implementation to maintain — if the response shape changes (e.g., a non-`text` content type), only one helper needs updating.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"ANSI color codes are not stripped from `ls` output lines before being used as `name`/`path`. If DOMShell ever colors a directory entry (or wraps a single error-like line in `\\x1b[31m…\\x1b[0m` without setting `isError`), each entry's `name` and `path` will contain raw escape sequences, and `path` will not round-trip back into a usable `cd`/`cat` argument. Consider stripping `_ANSI_CSI_RE` from each line (and from `raw`) before constructing the entries, mirroring the cleanup done in `_is_error`.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"When the daemon path fails and falls back to spawning a fresh server (lines 520–527), `arguments` is reused as-is and still carries the `group_id` captured from the dead daemon's session. If that lane id was assigned by/scoped to the now-defunct daemon process (rather than being a stable Chrome-side identifier), the fallback call will be pinned to a lane the new server doesn't know about. Consider clarifying in a comment whether DOMShell lane ids are stable across server processes; if not, the fallback should clear `group_id` before retrying.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -130,13 +498,32 @@ async def _call_tool(\n \"\"\"\n global _daemon_session, _daemon_read, _daemon_write\n \n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Reuse the previously-captured DOMShell lane so this call lands in the\n+ # same Chrome tab-group as the prior commands in this session. Without\n+ # this, every fresh stdio ClientSession would be assigned a brand-new\n+ # lane and `page open` / `fs ls` etc. would run in disjoint browser\n+ # state. The very first call leaves group_id unset so DOMShell\n+ # auto-assigns; _capture_lane stores that id on the session for the\n+ # next call.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"This summary omits the anchor (`cd %here%`) and restore (`cd %here%/<wd>`) calls that wrap the focus/type pair for absolute paths — the actual sequence is up to four calls (anchor → focus → type → restore), as the performance note below acknowledges. Consider rewording the opening to mention the anchor/restore so the high-level description matches the implementation.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -317,98 +869,239 @@ def click(path: str, use_daemon: bool = False) -> dict:\n >>> click(\"/main/button[0]\")\n {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Require a live daemon before skipping session checks**\n\nWhen a direct wrapper caller passes `use_daemon=True` without first calling `start_daemon()` (or after `_call_execute` has stopped a dead daemon), this guard treats the call as safe even though `_call_execute` falls through to fresh per-command MCP clients whenever `_daemon_session is None`. For split wrappers such as `backend.ls(\"/main\", use_daemon=True, session=None)` or `type_text(..., use_daemon=True, session=None)`, the anchor/focus and the operation can then run in different DOMShell lanes, so paths resolve from the wrong cwd or typing happens without the intended focus; gate this on an actually live daemon or still require a session.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Use recursive grep for element searches**\n\nDOMShell 2's shell examples use `grep -r ...` for standalone Accessibility Tree searches, while plain `grep` is shown as a pipe filter. Migrating the old structured `domshell_grep` call to `grep <pattern>` means `cli-anything-browser fs grep Login` can fail to walk the tree (or only filter the current input/current node) and miss matches outside the cwd; the rooted branch builds the same plain command as well, so preserve the previous tool semantics by invoking recursive grep.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +613,495 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"cat: an element name is required — cannot cat the tab root. \"\n+ \"Use `ls` to list the root's children, or pass a specific name.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ op = asyncio.run(_call_execute(\n+ f\"grep {_q(pattern)}\", use_daemon, session=session,","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"This is a behavior regression for the common `fs cat` (no-arg) case. `fs.read_element` falls back to `session.working_dir` when the caller passes no path, and the session defaults `working_dir` to `\"/\"`. After this change, any user sitting at the tab root who runs `cat` (or `read_element(session, \"\")`) will hit this `ValueError` instead of getting the root element's content as before. Consider either translating an absolute-root cat into a tab-root cat command DOMShell accepts (e.g. anchoring with `cd %here%` and issuing `cat .` / `cat %here%`), or — at minimum — handling the root case at the `fs.read_element` layer so REPL users at `/` don't get a hard error. The same concern applies to `click(\"/\")`, though clicking the root is less of a real-world flow.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +613,501 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"cat: an element name is required — cannot cat the tab root. \"\n+ \"Use `ls` to list the root's children, or pass a specific name.\"\n+ )","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_q(pattern)` is called later in both the unrooted and rooted branches and already raises on newlines via the centralized check in `_q`. This explicit `_assert_single_line(\\\"pattern\\\", pattern)` is redundant with that guard and only differs in the error message wording. If the field-named message is the reason to keep it, that's fine — but consider dropping it for consistency with the rationale in `_q`'s docstring (which describes per-call `_assert_single_line` as the exception, not the rule), or document at this call site why `pattern` warrants the field-named variant while `url`, `path` (in `click`), etc. do not.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +613,501 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"cat: an element name is required — cannot cat the tab root. \"\n+ \"Use `ls` to list the root's children, or pass a specific name.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+ translated_path, path_abs = _translate_path(path)","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"Detecting any occurrence of `\\\\x1b[31m` anywhere in the text flags the result as an error. If DOMShell ever emits a multi-line successful response that includes a red-colored substring (e.g. a successful `grep` highlighting a match in red, or a `cat` dump that echoes page text containing the red color code), this will misclassify it as an error and short-circuit downstream wrappers (anchor → op → restore would skip the op). Consider scoping the check to lines that begin with `\\\\x1b[31m` (i.e. the whole line is the red-wrapped error), or matching the full `\\\\x1b[31m...\\\\x1b[0m` envelope at line start, so non-error red usage doesn't trigger the safety chain.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The parser stuffs the entire raw line into both `name` and `path` and leaves `role` empty, which means callers that previously distinguished elements by role (and any future code that builds child paths from `path`) will silently degrade — directory entries currently retain trailing `/`, indexed entries carry brackets, etc. The docstring acknowledges this as a follow-up, but it is worth filing a tracking issue and/or adding a `# TODO` referencing the upstream DOMShell text-format question so this minimum-viable parser doesn't quietly become permanent.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Treat / as an explicit grep root**\n\nWhen a caller supplies `path=\"/\"`, `_translate_path` returns an empty translated path with `path_abs=True`, but this branch treats it the same as an omitted path and runs a bare `grep -r` in the lane's current cwd. In the CLI, `fs grep Login /` from `session.working_dir == \"/main\"` therefore searches `/main` instead of anchoring at the tab root, so explicit root-scoped searches can return the wrong subset of matches.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +613,501 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"cat: an element name is required — cannot cat the tab root. \"\n+ \"Use `ls` to list the root's children, or pass a specific name.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Reuse the daemon lane when no session is passed**\n\nWhen a caller uses the public wrappers directly with `use_daemon=True` but without a harness `Session`, every call still sends `group_id=\"new\"`; by this module's own lane handling, that asks DOMShell to create a fresh isolated lane on each `domshell_execute`. This breaks daemon-mode workflows like `open_url(..., use_daemon=True)` followed by `ls(use_daemon=True)`, because the second command runs in a new lane instead of the page opened by the first command. Store a daemon-level lane id or avoid forcing `\"new\"` for the live daemon/no-session path.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -130,13 +498,40 @@ async def _call_tool(\n \"\"\"\n global _daemon_session, _daemon_read, _daemon_write\n \n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling for non-daemon mode: every fresh stdio ClientSession\n+ # would otherwise be assigned a brand-new lane, scattering `page open`\n+ # / `fs ls` / etc. across disjoint browser state. So we name the lane\n+ # explicitly on every call:\n+ # • subsequent calls → group_id=<previously captured lane id>\n+ # • very first call → group_id=\"new\" — DOMShell creates a fresh\n+ # isolated lane and returns its id in the [lane: ...] marker,\n+ # which `_capture_lane` stores on the session for next time.\n+ # DOMShell 2.0.2 deprecated omitting `group_id` entirely (emits a\n+ # [DEPRECATION] warning in the reply; hard error in 3.0.0). Passing\n+ # \"new\" on the first call matches our actual intent — we want our own\n+ # private lane, not the shared one — and silences the deprecation\n+ # warning across every REPL session.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The current `group_id` selection uses `\"shared\"` whenever `use_daemon=True`, even when a daemon connection is not actually being used (i.e., `_daemon_session is None` and the code falls through to spawning a new stdio session). That contradicts the comment rationale (shared lane is “sticky across calls” because of the persistent daemon connection) and can also create unintended cross-call/cross-client state sharing when per-command sessions are spawned. Consider setting `group_id=\"shared\"` only when the call is truly going through the persistent daemon session (`use_daemon and _daemon_session is not None`), and otherwise use `\"new\"` (or require the daemon to be started) so non-daemonized spawned sessions remain isolated/predictable.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -130,13 +498,45 @@ async def _call_tool(\n \"\"\"\n global _daemon_session, _daemon_read, _daemon_write\n \n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling. DOMShell 2.0.2 deprecated omitting `group_id`\n+ # (emits a [DEPRECATION] warning in the reply; hard error in 3.0.0),\n+ # so we name the lane explicitly on every call. Three cases:\n+ # • subsequent calls (session has captured lane) → reuse that lane.\n+ # • non-daemon first call → group_id=\"new\" — DOMShell creates a\n+ # fresh isolated lane and returns its id in the [lane: ...]\n+ # marker, which `_capture_lane` stores on the session for next\n+ # time.\n+ # • daemon-mode first call without a Session → group_id=\"shared\"\n+ # — the daemon's persistent connection has its own default lane\n+ # that stays sticky across calls, so direct (sessionless) daemon\n+ # workflows like `open_url(use_daemon=True)` followed by\n+ # `ls(use_daemon=True)` share browser state naturally. Using\n+ # \"new\" here would mint a fresh isolated lane per call and lose\n+ # the page just opened (Codex P2 regression caught on the\n+ # initial 2.0.2 migration commit be62f843b5).\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon:\n+ arguments[\"group_id\"] = \"shared\"\n+ else:\n+ arguments[\"group_id\"] = \"new\"","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_extract_lane_id()` re-implements the same `content[*].text` concatenation logic as `_extract_text()`. Refactoring `_extract_lane_id()` to call `_extract_text(result)` would remove duplication and reduce the chance of these two helpers drifting in behavior (e.g., if content structure handling changes).","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_extract_lane_id()` re-implements the same `content[*].text` concatenation logic as `_extract_text()`. Refactoring `_extract_lane_id()` to call `_extract_text(result)` would remove duplication and reduce the chance of these two helpers drifting in behavior (e.g., if content structure handling changes).","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,17 +121,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"This table states several wrappers are executed as a “single multi-line call”, but the implementation intentionally uses multiple separate `_call_execute(...)` calls for split-and-check/error-gating (e.g., `ls`/`cat`/`click`/rooted `grep` are separate anchor → op → restore calls; absolute `type_text` is up to four calls). Please update the documentation to match the actual call structure and rationale (anchor failure short-circuits; restore is best-effort), otherwise readers may assume the backend relies on DOMShell’s continue-on-error multi-line semantics when it specifically avoids them for safety.","path":"browser/agent-harness/HARNESS.md","hunk":"@@ -37,30 +37,55 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"shared\"` and `group_id=\"new\"` keywords introduced in 2.0.2 to\n+declare lane intent explicitly (silences the deprecation warning that 2.0.2\n+added for omitted `group_id`; will become a hard error in DOMShell 3.0.0).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/HARNESS.md b/browser/agent-harness/HARNESS.md\nindex 7275a41a5a..2cd1ade02a 100644\n--- a/browser/agent-harness/HARNESS.md\n+++ b/browser/agent-harness/HARNESS.md\n@@ -37,30 +37,61 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"new\"` to declare lane intent explicitly on the first call of\n+each session and reuses the captured lane id on subsequent calls (silences\n+the deprecation warning that 2.0.2 added for omitted `group_id`; will\n+become a hard error in DOMShell 3.0.0). For direct daemon-mode callers\n+without a harness `Session`, the same scheme runs at module level — the\n+first call captures a lane id into `_daemon_lane_id` and subsequent calls\n+reuse it, preserving browser state across daemon-mode no-session calls\n+(see `domshell_backend.py`'s `_daemon_lane_id` declaration for the\n+stale-lane failure mode).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |\n+| `page open <url>` | `open <url>` |\n+| `page reload` | `refresh` |\n+| `page back` | `back` |\n+| `page forward` | `forward` |\n+\n+`<restore>` resolves to `cd %here%/<harness-working-dir>` (or `cd %here%`\n+when the harness is at the tab root) so the lane's cwd ends up where\n+the harness expects.\n \n ## Key Design Decisions\n \n"},{"comment":"This test docstring is now inconsistent with the updated behavior in `_call_execute()`, which always sets `group_id` (using `\"new\"` for first non-daemon calls, or `\"shared\"` for daemon/no-session). Updating the docstring to reflect the current contract will prevent confusion when reading the test suite (especially since nearby tests explicitly assert `\"new\"`/`\"shared\"`).","path":"browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py","hunk":"@@ -0,0 +1,1262 @@\n+\"\"\"Wire-format tests for cli_anything.browser.utils.domshell_backend.\n+\n+These tests patch the async ``_call_execute`` helper and assert the exact\n+command string sent to the DOMShell ``domshell_execute`` tool, so wire-format\n+regressions (quoting, command names, multi-line layout, restore ordering)\n+fail loudly.\n+\"\"\"\n+\n+from types import SimpleNamespace\n+from unittest.mock import AsyncMock, call, patch\n+\n+import pytest\n+\n+from cli_anything.browser.core.session import Session\n+from cli_anything.browser.utils import domshell_backend as backend\n+\n+\n+# ── Path translation: harness `/` vs DOMShell `~/` ───────────────────\n+\n+\n+def test_translate_path_root_is_absolute_empty():\n+ \"\"\"`/` → (\"\", True). Absolute target with no further subdir.\"\"\"\n+ assert backend._translate_path(\"/\") == (\"\", True)\n+\n+\n+def test_translate_path_empty_is_relative_empty():\n+ \"\"\"`\"\"` → (\"\", False). Bare/relative no-op; caller decides what to do.\"\"\"\n+ assert backend._translate_path(\"\") == (\"\", False)\n+\n+\n+def test_translate_path_strips_all_leading_slashes():\n+ \"\"\"`//main` collapses to `(\"main\", True)` via lstrip.\"\"\"\n+ assert backend._translate_path(\"/main\") == (\"main\", True)\n+ assert backend._translate_path(\"//main\") == (\"main\", True)\n+ assert backend._translate_path(\"///main\") == (\"main\", True)\n+\n+\n+def test_translate_path_preserves_relative():\n+ \"\"\"Relative paths pass through unchanged — DOMShell handles them.\"\"\"\n+ assert backend._translate_path(\"main\") == (\"main\", False)\n+ assert backend._translate_path(\"..\") == (\"..\", False)\n+ assert backend._translate_path(\".\") == (\".\", False)\n+\n+\n+# ── ls / cd / cat / click: absolute paths anchor at %here% ───────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_path_uses_three_separate_calls(mock_call):\n+ \"\"\"Split-and-check: anchor → bare ls → restore, three distinct calls.\n+\n+ Anchor success is load-bearing — if the cd fails, ls would run in\n+ the wrong cwd. Tested separately by\n+ test_ls_anchor_failure_short_circuits.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.ls(\"/main\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\" # anchor\n+ assert mock_call.call_args_list[1].args[0] == \"ls\" # op\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\" # restore\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_root_from_drifted_cwd_anchors_at_here(mock_call):\n+ \"\"\"The Codex P1 case: `ls /` from a drifted `/main` cwd.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.ls(\"/\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\" # anchor at tab root\n+ assert mock_call.call_args_list[1].args[0] == \"ls\" # bare ls\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\" # back to /main\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_relative_path_no_wrap(mock_call):\n+ \"\"\"Relative `ls main` runs against lane cwd — no anchor, no restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"main\")\n+ assert mock_call.call_args.args[0] == \"ls main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_path_with_spaces_quoted(mock_call):\n+ \"\"\"The `%here%/<deeper>` token is shell-quoted as one unit.\n+\n+ Upstream-smoked: `cd '%here%/<path>'` works in DOMShell 2.0.x — so\n+ whitespace and other shell metachars in absolute targets are safe.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/path with spaces\", session=_make_session(working_dir=\"/\"))\n+ # Anchor (first call) is the quoted form.\n+ assert mock_call.call_args_list[0].args[0] == \"cd '%here%/path with spaces'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_root_uses_here(mock_call):\n+ \"\"\"`cd /` → `cd %here%`. Single line — cd's purpose IS the new state.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/\")\n+ assert mock_call.call_args.args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_absolute_is_single_line_no_restore(mock_call):\n+ \"\"\"`cd /main` → `cd %here%/main`. One line, no restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/main\")\n+ assert mock_call.call_args.args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_subpath_with_indexing(mock_call):\n+ \"\"\"Brackets are shell-metachars — `_here_path` quotes the full token.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/main/div[0]\")\n+ assert mock_call.call_args.args[0] == \"cd '%here%/main/div[0]'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_relative_quoted(mock_call):\n+ \"\"\"Relative `cd main` is quoted via _q (handles spaces / metachars).\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"main\")\n+ assert mock_call.call_args.args[0] == \"cd main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_absolute_path_uses_three_separate_calls(mock_call):\n+ \"\"\"`cat /main/btn`: anchor at tab root → cat main/btn → restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+ backend.cat(\"/main/btn\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"cat main/btn\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_relative_no_wrap(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cat(\"main/btn\")\n+ assert mock_call.call_args.args[0] == \"cat main/btn\"\n+\n+\n+def test_cat_root_raises_value_error():\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.cat(\"/\")\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.cat(\"\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_absolute_path_uses_three_separate_calls(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.click(\"/main/button[0]\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"click 'main/button[0]'\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_relative_no_wrap(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.click(\"button[0]\")\n+ assert mock_call.call_args.args[0] == \"click 'button[0]'\"\n+\n+\n+def test_click_root_raises_value_error():\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.click(\"/\")\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.click(\"\")\n+\n+\n+# ── grep absolute-path anchoring ─────────────────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_absolute_uses_three_separate_calls(mock_call):\n+ \"\"\"Rooted grep (absolute): anchor → grep → restore, three distinct calls.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\n+ \"Login\", path=\"/main\", prev=\"/\", session=_make_session(working_dir=\"/\"),\n+ )\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\"\n+ assert mock_call.call_args_list[1].args[0] == \"grep -r Login\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_absolute_restores_to_session_wd(mock_call):\n+ \"\"\"Restore (third call) follows session.working_dir, not the `prev`\n+ kwarg, when the path is absolute — the lane cwd needs to end up\n+ where the harness thinks it is.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\n+ \"Login\", path=\"/main\", prev=\"/\", session=_make_session(working_dir=\"/main\"),\n+ )\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+\n+\n+# ── Anchor-failure short-circuit (the Codex P2 case per-wrapper) ─────\n+#\n+# If the anchor `cd` fails, the operation must NOT run — it would\n+# resolve against the wrong cwd and produce wrong-target results. Each\n+# wrapper that uses split-and-check mirrors `type_text`'s\n+# anchor-failure pattern.\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_anchor_failure_short_circuits(mock_call):\n+ \"\"\"ls absolute-path anchor failure → only the anchor call ran.\n+\n+ Uses DOMShell's actual error shape: ANSI-red-wrapped, command-\n+ prefixed (\"cd: ...\") — not the imaginary \"Error: ...\" prefix that\n+ silently bypassed ``_is_error`` for several rounds.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: tab 12345 is outside the session group\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.ls(\"/main\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_anchor_failure_short_circuits(mock_call):\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.cat(\"/main/btn\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_anchor_failure_short_circuits(mock_call):\n+ \"\"\"Critical for click: a misdirected click could trigger an\n+ unintended action. Anchor must halt before the click runs.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.click(\"/main/button[0]\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_anchor_failure_short_circuits(mock_call):\n+ \"\"\"Rooted grep with anchor failure → grep doesn't run (wrong-scope\n+ matches would be misleading). Restore also skipped because we\n+ never moved off the original cwd.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: /missing: No such directory\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.grep(\"Login\", path=\"/missing\", prev=\"/\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/missing\"\n+ assert \"error\" in result\n+\n+\n+# ── Absolute split-and-check requires session in non-daemon mode ─────\n+#\n+# Without a session (and without daemon mode), each `_call_execute` lands\n+# in a fresh DOMShell lane — the anchor cd's cwd doesn't carry over to\n+# the operation, producing wrong-scope output. Raise up front to surface\n+# the misuse instead of silently producing wrong results. (Mirrors\n+# `type_text`'s round-6.1 guard; propagated to ls/cat/click/grep in\n+# round 7.2 per Codex P2 #2.)\n+\n+\n+def test_ls_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.ls(\"/main\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_with_daemon_no_session_works(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — no\n+ session required.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/main\", use_daemon=True, session=None)\n+ # 3-call split-and-check still happens.\n+ assert mock_call.call_count == 3\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_relative_without_session_works(mock_call):\n+ \"\"\"Relative path runs as a single call — no anchor, no lane drift\n+ risk, so session=None is fine in non-daemon mode.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"main\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_cat_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.cat(\"/main/btn\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_relative_without_session_works(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cat(\"main/btn\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_click_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.click(\"/main/button[0]\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_relative_without_session_works(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.click(\"button[0]\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_grep_rooted_absolute_without_session_raises_in_non_daemon():\n+ \"\"\"Rooted grep with absolute path requires session for lane consistency.\"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\", session=None)\n+\n+\n+def test_grep_rooted_relative_without_session_raises_in_non_daemon():\n+ \"\"\"Rooted grep with RELATIVE path also requires session — both\n+ branches issue 3 separate calls and depend on shared lane state.\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.grep(\"Login\", path=\"dialog\", prev=\"/main\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_relative_with_daemon_no_session_works(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — no\n+ session required even for relative-rooted grep.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", path=\"dialog\", prev=\"/main\", use_daemon=True, session=None)\n+ # 3-call split-and-check still happens.\n+ assert mock_call.call_count == 3\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_without_session_works(mock_call):\n+ \"\"\"Unrooted grep is a single call — no session required.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+# ── _parse_execute_result: dict shapes per command ───────────────────\n+#\n+# DOMShell 2.x returns text content; the CLI was written for the\n+# pre-2.0 per-command tools that returned dicts. These tests lock in\n+# the translator's per-command shape contract so the CLI doesn't break\n+# on `result.get(...)` calls.\n+\n+\n+def test_parse_execute_result_ls_extracts_entries():\n+ result = _make_result(\"button[0]\\nlink[1]\\nimg[2]\\n[lane: 7]\")\n+ parsed = backend._parse_execute_result(result, \"ls\")\n+ assert parsed[\"entries\"] == [\n+ {\"name\": \"button[0]\", \"role\": \"\", \"path\": \"button[0]\"},\n+ {\"name\": \"link[1]\", \"role\": \"\", \"path\": \"link[1]\"},\n+ {\"name\": \"img[2]\", \"role\": \"\", \"path\": \"img[2]\"},\n+ ]\n+ # Lane marker is stripped from the raw text.\n+ assert \"[lane:\" not in parsed[\"raw\"]\n+\n+\n+def test_parse_execute_result_ls_empty_text_returns_empty_entries():\n+ parsed = backend._parse_execute_result(_make_result(\"[lane: 7]\"), \"ls\")\n+ assert parsed == {\"entries\": [], \"raw\": \"\"}\n+\n+\n+def test_parse_execute_result_grep_extracts_matches():\n+ result = _make_result(\n+ \"/main/button[0]\\n/main/link[1]\\n[lane: 7]\"\n+ )\n+ parsed = backend._parse_execute_result(result, \"grep\")\n+ assert parsed[\"matches\"] == [\"/main/button[0]\", \"/main/link[1]\"]\n+ assert \"[lane:\" not in parsed[\"raw\"]\n+\n+\n+def test_parse_execute_result_error_returns_error_dict():\n+ \"\"\"Errors get `error` AND `output` keys — the CLI checks `\"error\" in\n+ result` for cd-style guards but also pretty-prints `output`.\n+\n+ Uses the actual DOMShell error shape: ANSI-red-wrapped, command-\n+ prefixed (``ls: ...``).\n+ \"\"\"\n+ result = _make_result(\n+ \"\\x1b[31mls: main: No such directory\\x1b[0m\\n[lane: 7]\"\n+ )\n+ parsed = backend._parse_execute_result(result, \"ls\")\n+ assert \"error\" in parsed\n+ assert parsed[\"error\"].startswith(\"\\x1b[31mls:\")\n+ assert parsed[\"output\"] == parsed[\"error\"]\n+\n+\n+def test_parse_execute_result_default_for_non_nav_commands():\n+ \"\"\"cat/click/focus/type/refresh fall through to the generic\n+ ``{\"output\": text}`` shape (nav commands get their own branch —\n+ see test_parse_execute_result_nav_*).\"\"\"\n+ for cmd in (\"cat\", \"click\", \"focus\", \"type\", \"refresh\"):\n+ parsed = backend._parse_execute_result(\n+ _make_result(\"done\\n[lane: 1]\"), cmd,\n+ )\n+ assert parsed == {\"output\": \"done\"}\n+\n+\n+# ── Nav commands (back/forward/navigate/open): URL/title extraction ──\n+\n+\n+def test_parse_execute_result_nav_extracts_url_and_title():\n+ \"\"\"back/forward/navigate/open extract `url` and `title` so\n+ page.go_back/go_forward's `\"url\" in result` guards fire and\n+ session.set_url updates correctly. (Codex P2 #1.)\n+ \"\"\"\n+ fixture = _make_result(\n+ \"✓ Navigated back\\n\"\n+ \"URL: https://example.com/page\\n\"\n+ \"Title: Example Page\\n\"\n+ \"[lane: 7]\"\n+ )\n+ for cmd in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ parsed = backend._parse_execute_result(fixture, cmd)\n+ assert parsed[\"url\"] == \"https://example.com/page\"\n+ assert parsed[\"title\"] == \"Example Page\"\n+ # The raw output is preserved alongside.\n+ assert \"✓ Navigated back\" in parsed[\"output\"]\n+\n+\n+def test_parse_execute_result_nav_omits_url_when_missing():\n+ \"\"\"Malformed/early response without URL line → `output` only, no crash.\"\"\"\n+ parsed = backend._parse_execute_result(_make_result(\"✓ done\\n[lane: 1]\"), \"back\")\n+ assert parsed == {\"output\": \"✓ done\"}\n+ assert \"url\" not in parsed\n+ assert \"title\" not in parsed\n+\n+\n+def test_parse_execute_result_nav_extracts_url_without_title():\n+ \"\"\"A response with URL but no Title line still extracts the URL.\"\"\"\n+ parsed = backend._parse_execute_result(\n+ _make_result(\"URL: https://example.com/x\\n[lane: 1]\"), \"open\",\n+ )\n+ assert parsed[\"url\"] == \"https://example.com/x\"\n+ assert \"title\" not in parsed\n+\n+\n+def test_parse_execute_result_nav_title_handles_trailing_whitespace():\n+ \"\"\"Title regex strips trailing newline/whitespace.\"\"\"\n+ parsed = backend._parse_execute_result(\n+ _make_result(\n+ \"URL: https://example.com\\n\"\n+ \"Title: Spaced Title \\n\"\n+ \"[lane: 1]\"\n+ ),\n+ \"open\",\n+ )\n+ assert parsed[\"title\"] == \"Spaced Title\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_back_returns_dict_with_url_key(mock_call):\n+ \"\"\"End-to-end: backend.back() returns a dict with `url` so\n+ page.go_back's guard fires. (The Codex P2 #1 regression case.)\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\n+ \"✓ Navigated back\\n\"\n+ \"URL: https://previous.com\\n\"\n+ \"Title: Previous\\n\"\n+ \"[lane: 1]\"\n+ )\n+ result = backend.back(session=sess)\n+ assert \"url\" in result\n+ assert result[\"url\"] == \"https://previous.com\"\n+ assert result[\"title\"] == \"Previous\"\n+\n+\n+# ── End-to-end: wrappers return parsed dicts (not CallToolResult) ────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_returns_entries_dict(mock_call):\n+ \"\"\"`backend.ls(...)` must return ``{\"entries\": [...]}`` so the CLI\n+ doesn't AttributeError on `result.get(\"entries\", [])`. This is the\n+ Codex P1 shipped regression.\"\"\"\n+ mock_call.return_value = _make_result(\"button[0]\\n[lane: 1]\")\n+ result = backend.ls(\"main\")\n+ assert \"entries\" in result\n+ assert isinstance(result[\"entries\"], list)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_returns_matches_dict(mock_call):\n+ mock_call.return_value = _make_result(\"/main/btn[0]\\n[lane: 1]\")\n+ result = backend.grep(\"Login\")\n+ assert \"matches\" in result\n+ assert result[\"matches\"] == [\"/main/btn[0]\"]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_returns_dict_with_output(mock_call):\n+ \"\"\"`backend.cd(...)` returns a dict so `isinstance(result, dict)`\n+ in fs.change_directory works and `result.get(\"path\", path)` falls\n+ back cleanly.\"\"\"\n+ mock_call.return_value = _make_result(\"✓ Entered main\\n[lane: 1]\")\n+ result = backend.cd(\"/main\")\n+ assert isinstance(result, dict)\n+ assert \"error\" not in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_error_returns_error_dict(mock_call):\n+ \"\"\"`fs.change_directory` checks `\"error\" not in result` — make sure\n+ error paths surface the error key so the harness's working-dir\n+ update is correctly skipped. Uses the actual DOMShell error shape.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: /missing: No such directory\\x1b[0m\"\n+ )\n+ result = backend.cd(\"/missing\")\n+ assert \"error\" in result\n+\n+\n+# ── _is_error helper ─────────────────────────────────────────────────\n+\n+\n+def test_is_error_detects_isError_attribute():\n+ assert backend._is_error(SimpleNamespace(isError=True)) is True\n+ assert backend._is_error(SimpleNamespace(isError=False)) is False\n+\n+\n+def test_is_error_detects_dict_keys():\n+ assert backend._is_error({\"isError\": True}) is True\n+ assert backend._is_error({\"error\": \"boom\"}) is True\n+ assert backend._is_error({\"path\": \"/main\"}) is False\n+\n+\n+def test_is_error_detects_ansi_red_wrapper():\n+ \"\"\"Common DOMShell error shape: ANSI red around a command-prefixed\n+ message. These do NOT start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then ``startswith(\"error\")``\n+ failed every one of these, silently regressing the safety chain\n+ across every wrapper. Catch on the ``\\\\x1b[31m`` red marker\n+ instead.\n+ \"\"\"\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mcd: foo: No such directory\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mls: main: No such directory\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mcd: tab 12345 is outside the session group\\x1b[0m\")\n+ ) is True\n+\n+\n+def test_is_error_detects_explicit_error_prefix_without_ansi():\n+ \"\"\"Fallback: rarer non-coloured errors or pre-stripped input still\n+ detected via ``\"error:\"`` prefix.\n+ \"\"\"\n+ assert backend._is_error(_make_result(\"Error: bad command\")) is True\n+ assert backend._is_error(_make_result(\"ERROR: case insensitive\")) is True\n+\n+\n+def test_is_error_does_not_flag_success_in_other_colors():\n+ \"\"\"Anti-false-positive: only ``\\\\x1b[31m`` (red) signals an error.\n+ Success commonly wraps in ``\\\\x1b[32m`` (green) — must not flag.\n+ \"\"\"\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[32m✓ ok\\x1b[0m\")\n+ ) is False\n+ assert backend._is_error(\n+ _make_result(\"✓ command completed\")\n+ ) is False\n+ assert backend._is_error(\n+ _make_result(\"✓ Focused\\n[lane: 1]\")\n+ ) is False\n+\n+\n+def test_is_error_handles_empty():\n+ assert backend._is_error(_make_result(\"\")) is False\n+\n+\n+def test_is_error_handles_missing_content():\n+ assert backend._is_error(SimpleNamespace()) is False\n+\n+\n+# ── grep: command string and call sequencing ──────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_produces_single_grep_call(mock_call):\n+ \"\"\"Unrooted grep dispatches one ``grep -r <pattern>`` call.\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"Login\")\n+\n+ # session=None when no session is passed (default).\n+ assert mock_call.call_args_list == [call(\"grep -r Login\", False, session=None)]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_uses_recursive_flag(mock_call):\n+ \"\"\"Regression: pre-migration ``domshell_grep`` defaulted to\n+ recursive=True; the unrooted branch must preserve that by passing\n+ ``-r`` so nested matches aren't silently missed.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\")\n+ assert mock_call.call_args.args[0] == \"grep -r Login\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_uses_recursive_flag(mock_call):\n+ \"\"\"Regression: the rooted branch's middle call (the grep itself)\n+ must also pass ``-r``. The 3-call sequence is cd / grep -r / cd-back.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", path=\"main\", session=_make_session())\n+ # grep is the middle of the 3-call sequence.\n+ assert mock_call.call_args_list[1].args[0] == \"grep -r Login\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_emits_three_call_sequence(mock_call):\n+ \"\"\"Rooted grep is THREE separate ``_call_execute`` calls: anchor →\n+ grep → restore. Anchor success is load-bearing (would search the\n+ wrong subtree on cwd drift), so we can't fold this into a single\n+ multi-line continue-on-error call.\n+\n+ Lane sharing across the three calls is preserved via\n+ ``session.domshell_lane_id`` — see round-4 lane-persistence tests.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\", session=sess)\n+\n+ assert mock_call.call_args_list == [\n+ call(\"cd %here%/main\", False, session=sess),\n+ call(\"grep -r Login\", False, session=sess),\n+ call(\"cd %here%\", False, session=sess),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_quotes_path_with_spaces(mock_call):\n+ \"\"\"Absolute paths with whitespace are quoted as `cd '%here%/path with spaces'`.\n+\n+ Upstream-smoked: DOMShell's `cd` accepts the quoted form cleanly.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+\n+ backend.grep(\"Login\", path=\"/path with spaces\", prev=\"/\", session=sess)\n+\n+ # Three-call sequence — quoting applies to the anchor (first call).\n+ assert mock_call.call_args_list == [\n+ call(\"cd '%here%/path with spaces'\", False, session=sess),\n+ call(\"grep -r Login\", False, session=sess),\n+ call(\"cd %here%\", False, session=sess),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_pattern_with_shell_metacharacters_quoted(mock_call):\n+ \"\"\"Patterns with shell metacharacters get quoted (no injection via grep).\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"$(rm -rf /)\")\n+\n+ grep_cmd = mock_call.call_args_list[0].args[0]\n+ # shlex.quote will single-quote the dangerous payload.\n+ assert grep_cmd == \"grep -r '$(rm -rf /)'\"\n+\n+\n+def test_grep_rejects_positional_path():\n+ \"\"\"grep(pattern, path) — positional path raises TypeError.\n+\n+ Pre-migration callers writing ``grep(\"Login\", True)`` to mean\n+ ``use_daemon=True`` must not silently get ``path=True``.\n+ \"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", True) # type: ignore[misc]\n+\n+\n+def test_grep_rejects_positional_use_daemon():\n+ \"\"\"Even the third positional slot is blocked.\"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", \"/main\", \"/\", True) # type: ignore[misc]\n+\n+\n+def test_grep_keyword_use_daemon_still_works():\n+ \"\"\"Keyword call against the new signature still type-checks at call time.\"\"\"\n+ with patch.object(backend, \"_call_execute\", new_callable=AsyncMock) as mock_call:\n+ mock_call.return_value = {}\n+ backend.grep(\"Login\", use_daemon=True)\n+ assert mock_call.call_args_list == [call(\"grep -r Login\", True, session=None)]\n+\n+\n+# ── type_text: focus+type pairing and newline injection guard ─────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_emits_focus_then_type_with_session(mock_call):\n+ \"\"\"type_text issues focus + type as two separate execute calls.\n+\n+ The split is for safety: DOMShell's multi-line splitter continues\n+ past per-line errors, so a single ``focus path\\\\ntype text`` call\n+ would dispatch keys into stale focus if ``focus`` failed. Two calls\n+ with an error check between them prevents that.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\"✓ Focused\\n[lane: 1]\")\n+\n+ backend.type_text(\"search_input\", \"machine learning\", session=sess)\n+\n+ assert mock_call.call_count == 2\n+ # Relative path → no anchor wrap.\n+ assert mock_call.call_args_list[0].args[0] == \"focus search_input\"\n+ assert mock_call.call_args_list[1].args[0] == \"type 'machine learning'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_absolute_path_uses_four_separate_calls(mock_call):\n+ \"\"\"Absolute focus path: anchor → focus → type → restore, all distinct.\n+\n+ type_text is a safety chain, NOT a cleanup-line idiom: it must HALT\n+ on focus failure rather than continue past it. Wrapping focus in a\n+ multi-line ``cd %here%\\\\nfocus\\\\ncd <restore>`` would re-introduce\n+ the continue-on-error trap (the anchor's leading \"✓\" masks the\n+ focus error in the combined response). Split into four separate\n+ _call_execute calls, all sharing the persisted lane via session.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/main\")\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+\n+ backend.type_text(\"/main/input\", \"hello\", session=sess)\n+\n+ assert mock_call.call_count == 4\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"focus main/input\"\n+ assert mock_call.call_args_list[2].args[0] == \"type hello\"\n+ assert mock_call.call_args_list[3].args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_absolute_path_focus_failure_skips_type_and_restores(mock_call):\n+ \"\"\"The Codex P2 safety case: a stale absolute focus path must halt\n+ before type can dispatch keys into whatever was previously focused.\n+ The restore still runs so the lane cwd ends up where the harness\n+ expects.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/main\")\n+ mock_call.side_effect = [\n+ _make_result(\"✓ Entered tab 123\\n[lane: 1]\"), # cd anchor ok\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\"), # focus fails\n+ _make_result(\"✓ Typed\\n[lane: 1]\"), # MUST NOT be reached\n+ _make_result(\"✓\\n[lane: 1]\"), # restore\n+ ]\n+\n+ backend.type_text(\"/main/missing\", \"secret_password\", session=sess)\n+\n+ # Three calls: anchor, focus, restore. Type is skipped because the\n+ # focus error halts the safety chain before keys are dispatched.\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"focus main/missing\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+ # Critically — the \"type secret_password\" command was never sent.\n+ for call_args in mock_call.call_args_list:\n+ assert \"type\" not in call_args.args[0].split(\"\\n\")[0]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_anchor_failure_does_not_attempt_focus(mock_call):\n+ \"\"\"If even the anchor cd fails (e.g. chrome:// not debuggable),\n+ neither focus nor type runs. No restore needed because we never\n+ moved off the original cwd.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+\n+ backend.type_text(\"/some/path\", \"text\", session=sess)\n+\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_relative_path_focus_failure_skips_type(mock_call):\n+ \"\"\"Relative path focus failure: no anchor (no drift to restore), so\n+ just `focus`, then halt. Type MUST NOT run.\n+\n+ The absolute-path equivalent (with anchor + restore) is covered by\n+ test_type_text_absolute_path_focus_failure_skips_type_and_restores.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.side_effect = [\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\"), # focus fails\n+ _make_result(\"✓ Typed\"), # should NOT be reached\n+ ]\n+\n+ result = backend.type_text(\"stale_input\", \"secret_password\", session=sess)\n+\n+ # Only the focus call was made; the focus result was returned.\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"focus stale_input\"\n+ # The focus result is parsed (CLI consumes dicts, not CallToolResult).\n+ assert result == {\n+ \"error\": \"\\x1b[31mfocus: No such element\\x1b[0m\",\n+ \"output\": \"\\x1b[31mfocus: No such element\\x1b[0m\",\n+ }\n+\n+\n+def test_type_text_raises_without_session_in_non_daemon_mode():\n+ \"\"\"Non-daemon mode: the two halves must share a lane via group_id,\n+ which requires a session. Without one, raise.\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.type_text(\n+ \"search_input\", \"text\", use_daemon=False, session=None,\n+ )\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_allows_no_session_in_daemon_mode(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — session\n+ isn't required. Locks in the contract Copilot flagged.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+\n+ # No exception. Relative path → two calls (focus + type).\n+ backend.type_text(\"search_input\", \"hello\", use_daemon=True, session=None)\n+\n+ assert mock_call.call_count == 2\n+ assert mock_call.call_args_list[0].args[0] == \"focus search_input\"\n+ assert mock_call.call_args_list[1].args[0] == \"type hello\"\n+\n+\n+def test_type_text_raises_with_empty_path():\n+ with pytest.raises(ValueError, match=\"input path is required\"):\n+ backend.type_text(\"\", \"text\", session=_make_session())\n+ with pytest.raises(ValueError, match=\"input path is required\"):\n+ backend.type_text(\"/\", \"text\", session=_make_session())\n+\n+\n+def test_type_text_rejects_newline_in_text():\n+ \"\"\"``\\\\n`` in text would inject a new DOMShell command — must raise.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\nline2\")\n+\n+\n+def test_type_text_rejects_carriage_return_in_text():\n+ \"\"\"``\\\\r`` is just as dangerous as ``\\\\n`` for DOMShell's line splitter.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\rline2\")\n+\n+\n+def test_type_text_rejects_newline_in_path():\n+ \"\"\"A newline in the path argument also injects — guard both fields.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"input\\nclick /admin\", \"anything\")\n+\n+\n+# ── grep: newline guard on rooted multi-step path ─────────────────────\n+\n+\n+def test_grep_rejects_newline_in_path():\n+ \"\"\"Rooted grep interpolates path into a multi-line cd/grep/cd — reject newlines.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\\nclick /admin\", prev=\"/\")\n+\n+\n+def test_grep_rejects_newline_in_pattern():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\\nclick /admin\", path=\"/main\", prev=\"/\")\n+\n+\n+def test_grep_rejects_newline_in_prev():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\\nclick /admin\")\n+\n+\n+# ── Centralized newline guard in _q ──────────────────────────────────\n+#\n+# The per-wrapper _assert_single_line calls above cover type_text and\n+# rooted grep with field-named error messages. The newline check inside\n+# _q itself catches the same class of injection for every OTHER wrapper\n+# that flows user input through the quoting layer (open_url, click, cd,\n+# cat, unrooted grep, etc.) — without needing a per-call guard at each\n+# site.\n+\n+\n+def test_q_rejects_line_feeds():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\nbar\")\n+\n+\n+def test_q_rejects_carriage_returns():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\rbar\")\n+\n+\n+def test_q_accepts_normal_strings():\n+ \"\"\"Plain strings pass through to shlex.quote unchanged.\"\"\"\n+ assert backend._q(\"simple\") == \"simple\"\n+ assert backend._q(\"hello world\") == \"'hello world'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_unrooted_grep_pattern_rejects_newlines(mock_call):\n+ \"\"\"The unrooted grep path was not field-guarded — _q catches it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.grep(\"evil\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_open_url_rejects_newlines(mock_call):\n+ \"\"\"open_url has no per-call _assert_single_line — _q must catch it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.open_url(\"https://example.com\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_rejects_newlines(mock_call):\n+ \"\"\"click is covered structurally by _q without a per-call guard.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.click(\"/main/button[0]\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_rejects_newlines(mock_call):\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.cd(\"/main\\nclick /admin\")\n+\n+\n+# ── DOMShell lane persistence across _call_execute calls ─────────────\n+#\n+# DOMShell 2.x assigns a fresh lane (Chrome tab-group) to every new MCP\n+# session. In non-daemon mode each _call_execute opens its own stdio\n+# ClientSession, so without explicit group_id every command would land\n+# in a brand-new lane and lose browser state from the previous call.\n+# The fix: parse the trailing \"[lane: <id>]\" marker DOMShell appends to\n+# each reply, store it on the harness Session, and pass group_id=<id>\n+# on every subsequent call.\n+\n+\n+def _make_session(\n+ working_dir: str = \"/\",\n+ daemon_mode: bool = False,\n+ lane_id=None,\n+):\n+ \"\"\"Build a minimal session fixture compatible with the backend's\n+ ``getattr``-style access (working_dir, daemon_mode, domshell_lane_id).\"\"\"\n+ return SimpleNamespace(\n+ working_dir=working_dir,\n+ daemon_mode=daemon_mode,\n+ domshell_lane_id=lane_id,\n+ )\n+\n+\n+def _make_result(text: str):\n+ \"\"\"Build a fake CallToolResult whose ``content[0].text`` is ``text``.\"\"\"\n+ return SimpleNamespace(content=[SimpleNamespace(text=text)])\n+\n+\n+# ── _extract_lane_id ────────────────────────────────────────────────\n+\n+\n+def test_extract_lane_id_parses_trailing_marker():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: 12345]\")) == \"12345\"\n+\n+\n+def test_extract_lane_id_handles_trailing_whitespace():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: lane-abc]\\n\")) == \"lane-abc\"\n+\n+\n+def test_extract_lane_id_ignores_shared_marker():\n+ \"\"\"`[lane: shared]` is DOMShell's no-isolation sentinel — must not pin to it.\"\"\"\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: shared]\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_when_marker_absent():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_for_empty_text():\n+ assert backend._extract_lane_id(_make_result(\"\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_when_content_missing():\n+ assert backend._extract_lane_id(SimpleNamespace()) is None\n+\n+\n+# ── lane capture + propagation ──────────────────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_first_call_omits_group_id_and_captures_lane(mock_call):\n+ \"\"\"A session with no stored lane: first call has no group_id, captures the returned lane.\"\"\"","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py b/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\nnew file mode 100644\nindex 0000000000..2b75fe0097\n--- /dev/null\n+++ b/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\n@@ -0,0 +1,1337 @@\n+\"\"\"Wire-format tests for cli_anything.browser.utils.domshell_backend.\n+\n+These tests patch the async ``_call_execute`` helper and assert the exact\n+command string sent to the DOMShell ``domshell_execute`` tool, so wire-format\n+regressions (quoting, command names, multi-line layout, restore ordering)\n+fail loudly.\n+\"\"\"\n+\n+from types import SimpleNamespace\n+from unittest.mock import AsyncMock, call, patch\n+\n+import pytest\n+\n+from cli_anything.browser.core.session import Session\n+from cli_anything.browser.utils import domshell_backend as backend\n+\n+\n+# ── Path translation: harness `/` vs DOMShell `~/` ───────────────────\n+\n+\n+def test_translate_path_root_is_absolute_empty():\n+ \"\"\"`/` → (\"\", True). Absolute target with no further subdir.\"\"\"\n+ assert backend._translate_path(\"/\") == (\"\", True)\n+\n+\n+def test_translate_path_empty_is_relative_empty():\n+ \"\"\"`\"\"` → (\"\", False). Bare/relative no-op; caller decides what to do.\"\"\"\n+ assert backend._translate_path(\"\") == (\"\", False)\n+\n+\n+def test_translate_path_strips_all_leading_slashes():\n+ \"\"\"`//main` collapses to `(\"main\", True)` via lstrip.\"\"\"\n+ assert backend._translate_path(\"/main\") == (\"main\", True)\n+ assert backend._translate_path(\"//main\") == (\"main\", True)\n+ assert backend._translate_path(\"///main\") == (\"main\", True)\n+\n+\n+def test_translate_path_preserves_relative():\n+ \"\"\"Relative paths pass through unchanged — DOMShell handles them.\"\"\"\n+ assert backend._translate_path(\"main\") == (\"main\", False)\n+ assert backend._translate_path(\"..\") == (\"..\", False)\n+ assert backend._translate_path(\".\") == (\".\", False)\n+\n+\n+# ── ls / cd / cat / click: absolute paths anchor at %here% ───────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_path_uses_three_separate_calls(mock_call):\n+ \"\"\"Split-and-check: anchor → bare ls → restore, three distinct calls.\n+\n+ Anchor success is load-bearing — if the cd fails, ls would run in\n+ the wrong cwd. Tested separately by\n+ test_ls_anchor_failure_short_circuits.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.ls(\"/main\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\" # anchor\n+ assert mock_call.call_args_list[1].args[0] == \"ls\" # op\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\" # restore\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_root_from_drifted_cwd_anchors_at_here(mock_call):\n+ \"\"\"The Codex P1 case: `ls /` from a drifted `/main` cwd.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.ls(\"/\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\" # anchor at tab root\n+ assert mock_call.call_args_list[1].args[0] == \"ls\" # bare ls\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\" # back to /main\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_relative_path_no_wrap(mock_call):\n+ \"\"\"Relative `ls main` runs against lane cwd — no anchor, no restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"main\")\n+ assert mock_call.call_args.args[0] == \"ls main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_path_with_spaces_quoted(mock_call):\n+ \"\"\"The `%here%/<deeper>` token is shell-quoted as one unit.\n+\n+ Upstream-smoked: `cd '%here%/<path>'` works in DOMShell 2.0.x — so\n+ whitespace and other shell metachars in absolute targets are safe.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/path with spaces\", session=_make_session(working_dir=\"/\"))\n+ # Anchor (first call) is the quoted form.\n+ assert mock_call.call_args_list[0].args[0] == \"cd '%here%/path with spaces'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_root_uses_here(mock_call):\n+ \"\"\"`cd /` → `cd %here%`. Single line — cd's purpose IS the new state.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/\")\n+ assert mock_call.call_args.args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_absolute_is_single_line_no_restore(mock_call):\n+ \"\"\"`cd /main` → `cd %here%/main`. One line, no restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/main\")\n+ assert mock_call.call_args.args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_subpath_with_indexing(mock_call):\n+ \"\"\"Brackets are shell-metachars — `_here_path` quotes the full token.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"/main/div[0]\")\n+ assert mock_call.call_args.args[0] == \"cd '%here%/main/div[0]'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_relative_quoted(mock_call):\n+ \"\"\"Relative `cd main` is quoted via _q (handles spaces / metachars).\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cd(\"main\")\n+ assert mock_call.call_args.args[0] == \"cd main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_absolute_path_uses_three_separate_calls(mock_call):\n+ \"\"\"`cat /main/btn`: anchor at tab root → cat main/btn → restore.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+ backend.cat(\"/main/btn\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"cat main/btn\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_relative_no_wrap(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cat(\"main/btn\")\n+ assert mock_call.call_args.args[0] == \"cat main/btn\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_root_path_does_not_raise_and_returns_parseable_result(mock_call):\n+ \"\"\"backend.cat(\"/\") and backend.cat(\"\") at the absolute root should\n+ NOT raise a Python ValueError. Pre-migration behavior was to send\n+ ``cat ''`` to DOMShell and surface its ``Usage: cat <name>`` error\n+ string; the round-5 Python-side guard converted the kernel error\n+ into a ValueError, which broke ``fs.read_element(session, \"\")``\n+ callers landed at ``/``. @yuh-yang R3 blocker 1 required restoring\n+ pre-migration behavior — guard removed, both inputs now reach\n+ DOMShell, which has the same ``if (!targetName)`` check and\n+ returns its standard Usage error.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mUsage: cat <name> (see cat --help)\\x1b[0m\\n[lane: shared]\"\n+ )\n+ sess = _make_session(working_dir=\"/\") # satisfies absolute branch's session check\n+\n+ # MUST NOT raise — that was the regression.\n+ result_root = backend.cat(\"/\", session=sess)\n+ result_empty = backend.cat(\"\")\n+\n+ # Both surface DOMShell's error as a parsed dict, not a Python exception.\n+ for r in (result_root, result_empty):\n+ assert isinstance(r, dict)\n+ # _parse_execute_result detects ANSI red → routes through error path.\n+ assert \"error\" in r\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_absolute_path_uses_three_separate_calls(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/main\")\n+ backend.click(\"/main/button[0]\", session=sess)\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"click 'main/button[0]'\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_relative_no_wrap(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.click(\"button[0]\")\n+ assert mock_call.call_args.args[0] == \"click 'button[0]'\"\n+\n+\n+def test_click_root_raises_value_error():\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.click(\"/\")\n+ with pytest.raises(ValueError, match=\"element name is required\"):\n+ backend.click(\"\")\n+\n+\n+# ── grep absolute-path anchoring ─────────────────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_absolute_uses_three_separate_calls(mock_call):\n+ \"\"\"Rooted grep (absolute): anchor → grep → restore, three distinct calls.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\n+ \"Login\", path=\"/main\", prev=\"/\", session=_make_session(working_dir=\"/\"),\n+ )\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\"\n+ assert mock_call.call_args_list[1].args[0] == \"grep -r Login\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_absolute_restores_to_session_wd(mock_call):\n+ \"\"\"Restore (third call) follows session.working_dir, not the `prev`\n+ kwarg, when the path is absolute — the lane cwd needs to end up\n+ where the harness thinks it is.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\n+ \"Login\", path=\"/main\", prev=\"/\", session=_make_session(working_dir=\"/main\"),\n+ )\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+\n+\n+# ── Anchor-failure short-circuit (the Codex P2 case per-wrapper) ─────\n+#\n+# If the anchor `cd` fails, the operation must NOT run — it would\n+# resolve against the wrong cwd and produce wrong-target results. Each\n+# wrapper that uses split-and-check mirrors `type_text`'s\n+# anchor-failure pattern.\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_anchor_failure_short_circuits(mock_call):\n+ \"\"\"ls absolute-path anchor failure → only the anchor call ran.\n+\n+ Uses DOMShell's actual error shape: ANSI-red-wrapped, command-\n+ prefixed (\"cd: ...\") — not the imaginary \"Error: ...\" prefix that\n+ silently bypassed ``_is_error`` for several rounds.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: tab 12345 is outside the session group\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.ls(\"/main\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/main\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_anchor_failure_short_circuits(mock_call):\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.cat(\"/main/btn\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_anchor_failure_short_circuits(mock_call):\n+ \"\"\"Critical for click: a misdirected click could trigger an\n+ unintended action. Anchor must halt before the click runs.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.click(\"/main/button[0]\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert \"error\" in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_anchor_failure_short_circuits(mock_call):\n+ \"\"\"Rooted grep with anchor failure → grep doesn't run (wrong-scope\n+ matches would be misleading). Restore also skipped because we\n+ never moved off the original cwd.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: /missing: No such directory\\x1b[0m\"\n+ )\n+ sess = _make_session(working_dir=\"/\")\n+ result = backend.grep(\"Login\", path=\"/missing\", prev=\"/\", session=sess)\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%/missing\"\n+ assert \"error\" in result\n+\n+\n+# ── Absolute split-and-check requires session in non-daemon mode ─────\n+#\n+# Without a session (and without daemon mode), each `_call_execute` lands\n+# in a fresh DOMShell lane — the anchor cd's cwd doesn't carry over to\n+# the operation, producing wrong-scope output. Raise up front to surface\n+# the misuse instead of silently producing wrong results. (Mirrors\n+# `type_text`'s round-6.1 guard; propagated to ls/cat/click/grep in\n+# round 7.2 per Codex P2 #2.)\n+\n+\n+def test_ls_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.ls(\"/main\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_absolute_with_daemon_no_session_works(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — no\n+ session required.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/main\", use_daemon=True, session=None)\n+ # 3-call split-and-check still happens.\n+ assert mock_call.call_count == 3\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_relative_without_session_works(mock_call):\n+ \"\"\"Relative path runs as a single call — no anchor, no lane drift\n+ risk, so session=None is fine in non-daemon mode.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"main\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_cat_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.cat(\"/main/btn\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cat_relative_without_session_works(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.cat(\"main/btn\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_click_absolute_without_session_raises_in_non_daemon():\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.click(\"/main/button[0]\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_relative_without_session_works(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.click(\"button[0]\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+def test_grep_rooted_absolute_without_session_raises_in_non_daemon():\n+ \"\"\"Rooted grep with absolute path requires session for lane consistency.\"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\", session=None)\n+\n+\n+def test_grep_rooted_relative_without_session_raises_in_non_daemon():\n+ \"\"\"Rooted grep with RELATIVE path also requires session — both\n+ branches issue 3 separate calls and depend on shared lane state.\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.grep(\"Login\", path=\"dialog\", prev=\"/main\", session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_relative_with_daemon_no_session_works(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — no\n+ session required even for relative-rooted grep.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", path=\"dialog\", prev=\"/main\", use_daemon=True, session=None)\n+ # 3-call split-and-check still happens.\n+ assert mock_call.call_count == 3\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_without_session_works(mock_call):\n+ \"\"\"Unrooted grep is a single call — no session required.\"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", session=None)\n+ assert mock_call.call_count == 1\n+\n+\n+# ── _parse_execute_result: dict shapes per command ───────────────────\n+#\n+# DOMShell 2.x returns text content; the CLI was written for the\n+# pre-2.0 per-command tools that returned dicts. These tests lock in\n+# the translator's per-command shape contract so the CLI doesn't break\n+# on `result.get(...)` calls.\n+\n+\n+def test_parse_execute_result_ls_extracts_entries():\n+ result = _make_result(\"button[0]\\nlink[1]\\nimg[2]\\n[lane: 7]\")\n+ parsed = backend._parse_execute_result(result, \"ls\")\n+ assert parsed[\"entries\"] == [\n+ {\"name\": \"button[0]\", \"role\": \"\", \"path\": \"button[0]\"},\n+ {\"name\": \"link[1]\", \"role\": \"\", \"path\": \"link[1]\"},\n+ {\"name\": \"img[2]\", \"role\": \"\", \"path\": \"img[2]\"},\n+ ]\n+ # Lane marker is stripped from the raw text.\n+ assert \"[lane:\" not in parsed[\"raw\"]\n+\n+\n+def test_parse_execute_result_ls_empty_text_returns_empty_entries():\n+ parsed = backend._parse_execute_result(_make_result(\"[lane: 7]\"), \"ls\")\n+ assert parsed == {\"entries\": [], \"raw\": \"\"}\n+\n+\n+def test_parse_execute_result_grep_extracts_matches():\n+ result = _make_result(\n+ \"/main/button[0]\\n/main/link[1]\\n[lane: 7]\"\n+ )\n+ parsed = backend._parse_execute_result(result, \"grep\")\n+ assert parsed[\"matches\"] == [\"/main/button[0]\", \"/main/link[1]\"]\n+ assert \"[lane:\" not in parsed[\"raw\"]\n+\n+\n+def test_parse_execute_result_error_returns_error_dict():\n+ \"\"\"Errors get `error` AND `output` keys — the CLI checks `\"error\" in\n+ result` for cd-style guards but also pretty-prints `output`.\n+\n+ Uses the actual DOMShell error shape: ANSI-red-wrapped, command-\n+ prefixed (``ls: ...``).\n+ \"\"\"\n+ result = _make_result(\n+ \"\\x1b[31mls: main: No such directory\\x1b[0m\\n[lane: 7]\"\n+ )\n+ parsed = backend._parse_execute_result(result, \"ls\")\n+ assert \"error\" in parsed\n+ assert parsed[\"error\"].startswith(\"\\x1b[31mls:\")\n+ assert parsed[\"output\"] == parsed[\"error\"]\n+\n+\n+def test_parse_execute_result_default_for_non_nav_commands():\n+ \"\"\"cat/click/focus/type/refresh fall through to the generic\n+ ``{\"output\": text}`` shape (nav commands get their own branch —\n+ see test_parse_execute_result_nav_*).\"\"\"\n+ for cmd in (\"cat\", \"click\", \"focus\", \"type\", \"refresh\"):\n+ parsed = backend._parse_execute_result(\n+ _make_result(\"done\\n[lane: 1]\"), cmd,\n+ )\n+ assert parsed == {\"output\": \"done\"}\n+\n+\n+# ── Nav commands (back/forward/navigate/open): URL/title extraction ──\n+\n+\n+def test_parse_execute_result_nav_extracts_url_and_title():\n+ \"\"\"back/forward/navigate/open extract `url` and `title` so\n+ page.go_back/go_forward's `\"url\" in result` guards fire and\n+ session.set_url updates correctly. (Codex P2 #1.)\n+ \"\"\"\n+ fixture = _make_result(\n+ \"✓ Navigated back\\n\"\n+ \"URL: https://example.com/page\\n\"\n+ \"Title: Example Page\\n\"\n+ \"[lane: 7]\"\n+ )\n+ for cmd in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ parsed = backend._parse_execute_result(fixture, cmd)\n+ assert parsed[\"url\"] == \"https://example.com/page\"\n+ assert parsed[\"title\"] == \"Example Page\"\n+ # The raw output is preserved alongside.\n+ assert \"✓ Navigated back\" in parsed[\"output\"]\n+\n+\n+def test_parse_execute_result_nav_omits_url_when_missing():\n+ \"\"\"Malformed/early response without URL line → `output` only, no crash.\"\"\"\n+ parsed = backend._parse_execute_result(_make_result(\"✓ done\\n[lane: 1]\"), \"back\")\n+ assert parsed == {\"output\": \"✓ done\"}\n+ assert \"url\" not in parsed\n+ assert \"title\" not in parsed\n+\n+\n+def test_parse_execute_result_nav_extracts_url_without_title():\n+ \"\"\"A response with URL but no Title line still extracts the URL.\"\"\"\n+ parsed = backend._parse_execute_result(\n+ _make_result(\"URL: https://example.com/x\\n[lane: 1]\"), \"open\",\n+ )\n+ assert parsed[\"url\"] == \"https://example.com/x\"\n+ assert \"title\" not in parsed\n+\n+\n+def test_parse_execute_result_nav_title_handles_trailing_whitespace():\n+ \"\"\"Title regex strips trailing newline/whitespace.\"\"\"\n+ parsed = backend._parse_execute_result(\n+ _make_result(\n+ \"URL: https://example.com\\n\"\n+ \"Title: Spaced Title \\n\"\n+ \"[lane: 1]\"\n+ ),\n+ \"open\",\n+ )\n+ assert parsed[\"title\"] == \"Spaced Title\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_back_returns_dict_with_url_key(mock_call):\n+ \"\"\"End-to-end: backend.back() returns a dict with `url` so\n+ page.go_back's guard fires. (The Codex P2 #1 regression case.)\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\n+ \"✓ Navigated back\\n\"\n+ \"URL: https://previous.com\\n\"\n+ \"Title: Previous\\n\"\n+ \"[lane: 1]\"\n+ )\n+ result = backend.back(session=sess)\n+ assert \"url\" in result\n+ assert result[\"url\"] == \"https://previous.com\"\n+ assert result[\"title\"] == \"Previous\"\n+\n+\n+# ── End-to-end: wrappers return parsed dicts (not CallToolResult) ────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_ls_returns_entries_dict(mock_call):\n+ \"\"\"`backend.ls(...)` must return ``{\"entries\": [...]}`` so the CLI\n+ doesn't AttributeError on `result.get(\"entries\", [])`. This is the\n+ Codex P1 shipped regression.\"\"\"\n+ mock_call.return_value = _make_result(\"button[0]\\n[lane: 1]\")\n+ result = backend.ls(\"main\")\n+ assert \"entries\" in result\n+ assert isinstance(result[\"entries\"], list)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_returns_matches_dict(mock_call):\n+ mock_call.return_value = _make_result(\"/main/btn[0]\\n[lane: 1]\")\n+ result = backend.grep(\"Login\")\n+ assert \"matches\" in result\n+ assert result[\"matches\"] == [\"/main/btn[0]\"]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_returns_dict_with_output(mock_call):\n+ \"\"\"`backend.cd(...)` returns a dict so `isinstance(result, dict)`\n+ in fs.change_directory works and `result.get(\"path\", path)` falls\n+ back cleanly.\"\"\"\n+ mock_call.return_value = _make_result(\"✓ Entered main\\n[lane: 1]\")\n+ result = backend.cd(\"/main\")\n+ assert isinstance(result, dict)\n+ assert \"error\" not in result\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_error_returns_error_dict(mock_call):\n+ \"\"\"`fs.change_directory` checks `\"error\" not in result` — make sure\n+ error paths surface the error key so the harness's working-dir\n+ update is correctly skipped. Uses the actual DOMShell error shape.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: /missing: No such directory\\x1b[0m\"\n+ )\n+ result = backend.cd(\"/missing\")\n+ assert \"error\" in result\n+\n+\n+# ── _is_error helper ─────────────────────────────────────────────────\n+\n+\n+def test_is_error_detects_isError_attribute():\n+ assert backend._is_error(SimpleNamespace(isError=True)) is True\n+ assert backend._is_error(SimpleNamespace(isError=False)) is False\n+\n+\n+def test_is_error_detects_dict_keys():\n+ assert backend._is_error({\"isError\": True}) is True\n+ assert backend._is_error({\"error\": \"boom\"}) is True\n+ assert backend._is_error({\"path\": \"/main\"}) is False\n+\n+\n+def test_is_error_detects_ansi_red_wrapper():\n+ \"\"\"Common DOMShell error shape: ANSI red around a command-prefixed\n+ message. These do NOT start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then ``startswith(\"error\")``\n+ failed every one of these, silently regressing the safety chain\n+ across every wrapper. Catch on the ``\\\\x1b[31m`` red marker\n+ instead.\n+ \"\"\"\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mcd: foo: No such directory\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mls: main: No such directory\\x1b[0m\")\n+ ) is True\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[31mcd: tab 12345 is outside the session group\\x1b[0m\")\n+ ) is True\n+\n+\n+def test_is_error_detects_explicit_error_prefix_without_ansi():\n+ \"\"\"Fallback: rarer non-coloured errors or pre-stripped input still\n+ detected via ``\"error:\"`` prefix.\n+ \"\"\"\n+ assert backend._is_error(_make_result(\"Error: bad command\")) is True\n+ assert backend._is_error(_make_result(\"ERROR: case insensitive\")) is True\n+\n+\n+def test_is_error_does_not_flag_success_in_other_colors():\n+ \"\"\"Anti-false-positive: only ``\\\\x1b[31m`` (red) signals an error.\n+ Success commonly wraps in ``\\\\x1b[32m`` (green) — must not flag.\n+ \"\"\"\n+ assert backend._is_error(\n+ _make_result(\"\\x1b[32m✓ ok\\x1b[0m\")\n+ ) is False\n+ assert backend._is_error(\n+ _make_result(\"✓ command completed\")\n+ ) is False\n+ assert backend._is_error(\n+ _make_result(\"✓ Focused\\n[lane: 1]\")\n+ ) is False\n+\n+\n+def test_is_error_handles_empty():\n+ assert backend._is_error(_make_result(\"\")) is False\n+\n+\n+def test_is_error_handles_missing_content():\n+ assert backend._is_error(SimpleNamespace()) is False\n+\n+\n+# ── grep: command string and call sequencing ──────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_produces_single_grep_call(mock_call):\n+ \"\"\"Unrooted grep dispatches one ``grep -r <pattern>`` call.\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"Login\")\n+\n+ # session=None when no session is passed (default).\n+ assert mock_call.call_args_list == [call(\"grep -r Login\", False, session=None)]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_unrooted_uses_recursive_flag(mock_call):\n+ \"\"\"Regression: pre-migration ``domshell_grep`` defaulted to\n+ recursive=True; the unrooted branch must preserve that by passing\n+ ``-r`` so nested matches aren't silently missed.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\")\n+ assert mock_call.call_args.args[0] == \"grep -r Login\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_uses_recursive_flag(mock_call):\n+ \"\"\"Regression: the rooted branch's middle call (the grep itself)\n+ must also pass ``-r``. The 3-call sequence is cd / grep -r / cd-back.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.grep(\"Login\", path=\"main\", session=_make_session())\n+ # grep is the middle of the 3-call sequence.\n+ assert mock_call.call_args_list[1].args[0] == \"grep -r Login\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_emits_three_call_sequence(mock_call):\n+ \"\"\"Rooted grep is THREE separate ``_call_execute`` calls: anchor →\n+ grep → restore. Anchor success is load-bearing (would search the\n+ wrong subtree on cwd drift), so we can't fold this into a single\n+ multi-line continue-on-error call.\n+\n+ Lane sharing across the three calls is preserved via\n+ ``session.domshell_lane_id`` — see round-4 lane-persistence tests.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\", session=sess)\n+\n+ assert mock_call.call_args_list == [\n+ call(\"cd %here%/main\", False, session=sess),\n+ call(\"grep -r Login\", False, session=sess),\n+ call(\"cd %here%\", False, session=sess),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_rooted_quotes_path_with_spaces(mock_call):\n+ \"\"\"Absolute paths with whitespace are quoted as `cd '%here%/path with spaces'`.\n+\n+ Upstream-smoked: DOMShell's `cd` accepts the quoted form cleanly.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ sess = _make_session(working_dir=\"/\")\n+\n+ backend.grep(\"Login\", path=\"/path with spaces\", prev=\"/\", session=sess)\n+\n+ # Three-call sequence — quoting applies to the anchor (first call).\n+ assert mock_call.call_args_list == [\n+ call(\"cd '%here%/path with spaces'\", False, session=sess),\n+ call(\"grep -r Login\", False, session=sess),\n+ call(\"cd %here%\", False, session=sess),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_grep_pattern_with_shell_metacharacters_quoted(mock_call):\n+ \"\"\"Patterns with shell metacharacters get quoted (no injection via grep).\"\"\"\n+ mock_call.return_value = {}\n+\n+ backend.grep(\"$(rm -rf /)\")\n+\n+ grep_cmd = mock_call.call_args_list[0].args[0]\n+ # shlex.quote will single-quote the dangerous payload.\n+ assert grep_cmd == \"grep -r '$(rm -rf /)'\"\n+\n+\n+def test_grep_rejects_positional_path():\n+ \"\"\"grep(pattern, path) — positional path raises TypeError.\n+\n+ Pre-migration callers writing ``grep(\"Login\", True)`` to mean\n+ ``use_daemon=True`` must not silently get ``path=True``.\n+ \"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", True) # type: ignore[misc]\n+\n+\n+def test_grep_rejects_positional_use_daemon():\n+ \"\"\"Even the third positional slot is blocked.\"\"\"\n+ with pytest.raises(TypeError):\n+ backend.grep(\"Login\", \"/main\", \"/\", True) # type: ignore[misc]\n+\n+\n+def test_grep_keyword_use_daemon_still_works():\n+ \"\"\"Keyword call against the new signature still type-checks at call time.\"\"\"\n+ with patch.object(backend, \"_call_execute\", new_callable=AsyncMock) as mock_call:\n+ mock_call.return_value = {}\n+ backend.grep(\"Login\", use_daemon=True)\n+ assert mock_call.call_args_list == [call(\"grep -r Login\", True, session=None)]\n+\n+\n+# ── type_text: focus+type pairing and newline injection guard ─────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_emits_focus_then_type_with_session(mock_call):\n+ \"\"\"type_text issues focus + type as two separate execute calls.\n+\n+ The split is for safety: DOMShell's multi-line splitter continues\n+ past per-line errors, so a single ``focus path\\\\ntype text`` call\n+ would dispatch keys into stale focus if ``focus`` failed. Two calls\n+ with an error check between them prevents that.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\"✓ Focused\\n[lane: 1]\")\n+\n+ backend.type_text(\"search_input\", \"machine learning\", session=sess)\n+\n+ assert mock_call.call_count == 2\n+ # Relative path → no anchor wrap.\n+ assert mock_call.call_args_list[0].args[0] == \"focus search_input\"\n+ assert mock_call.call_args_list[1].args[0] == \"type 'machine learning'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_absolute_path_uses_four_separate_calls(mock_call):\n+ \"\"\"Absolute focus path: anchor → focus → type → restore, all distinct.\n+\n+ type_text is a safety chain, NOT a cleanup-line idiom: it must HALT\n+ on focus failure rather than continue past it. Wrapping focus in a\n+ multi-line ``cd %here%\\\\nfocus\\\\ncd <restore>`` would re-introduce\n+ the continue-on-error trap (the anchor's leading \"✓\" masks the\n+ focus error in the combined response). Split into four separate\n+ _call_execute calls, all sharing the persisted lane via session.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/main\")\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+\n+ backend.type_text(\"/main/input\", \"hello\", session=sess)\n+\n+ assert mock_call.call_count == 4\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"focus main/input\"\n+ assert mock_call.call_args_list[2].args[0] == \"type hello\"\n+ assert mock_call.call_args_list[3].args[0] == \"cd %here%/main\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_absolute_path_focus_failure_skips_type_and_restores(mock_call):\n+ \"\"\"The Codex P2 safety case: a stale absolute focus path must halt\n+ before type can dispatch keys into whatever was previously focused.\n+ The restore still runs so the lane cwd ends up where the harness\n+ expects.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/main\")\n+ mock_call.side_effect = [\n+ _make_result(\"✓ Entered tab 123\\n[lane: 1]\"), # cd anchor ok\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\"), # focus fails\n+ _make_result(\"✓ Typed\\n[lane: 1]\"), # MUST NOT be reached\n+ _make_result(\"✓\\n[lane: 1]\"), # restore\n+ ]\n+\n+ backend.type_text(\"/main/missing\", \"secret_password\", session=sess)\n+\n+ # Three calls: anchor, focus, restore. Type is skipped because the\n+ # focus error halts the safety chain before keys are dispatched.\n+ assert mock_call.call_count == 3\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+ assert mock_call.call_args_list[1].args[0] == \"focus main/missing\"\n+ assert mock_call.call_args_list[2].args[0] == \"cd %here%/main\"\n+ # Critically — the \"type secret_password\" command was never sent.\n+ for call_args in mock_call.call_args_list:\n+ assert \"type\" not in call_args.args[0].split(\"\\n\")[0]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_anchor_failure_does_not_attempt_focus(mock_call):\n+ \"\"\"If even the anchor cd fails (e.g. chrome:// not debuggable),\n+ neither focus nor type runs. No restore needed because we never\n+ moved off the original cwd.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\n+ \"\\x1b[31mcd: chrome:// not debuggable\\x1b[0m\"\n+ )\n+\n+ backend.type_text(\"/some/path\", \"text\", session=sess)\n+\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"cd %here%\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_relative_path_focus_failure_skips_type(mock_call):\n+ \"\"\"Relative path focus failure: no anchor (no drift to restore), so\n+ just `focus`, then halt. Type MUST NOT run.\n+\n+ The absolute-path equivalent (with anchor + restore) is covered by\n+ test_type_text_absolute_path_focus_failure_skips_type_and_restores.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.side_effect = [\n+ _make_result(\"\\x1b[31mfocus: No such element\\x1b[0m\"), # focus fails\n+ _make_result(\"✓ Typed\"), # should NOT be reached\n+ ]\n+\n+ result = backend.type_text(\"stale_input\", \"secret_password\", session=sess)\n+\n+ # Only the focus call was made; the focus result was returned.\n+ assert mock_call.call_count == 1\n+ assert mock_call.call_args_list[0].args[0] == \"focus stale_input\"\n+ # The focus result is parsed (CLI consumes dicts, not CallToolResult).\n+ assert result == {\n+ \"error\": \"\\x1b[31mfocus: No such element\\x1b[0m\",\n+ \"output\": \"\\x1b[31mfocus: No such element\\x1b[0m\",\n+ }\n+\n+\n+def test_type_text_raises_without_session_in_non_daemon_mode():\n+ \"\"\"Non-daemon mode: the two halves must share a lane via group_id,\n+ which requires a session. Without one, raise.\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"session\"):\n+ backend.type_text(\n+ \"search_input\", \"text\", use_daemon=False, session=None,\n+ )\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_type_text_allows_no_session_in_daemon_mode(mock_call):\n+ \"\"\"Daemon mode shares lane via the persistent connection — session\n+ isn't required. Locks in the contract Copilot flagged.\n+ \"\"\"\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+\n+ # No exception. Relative path → two calls (focus + type).\n+ backend.type_text(\"search_input\", \"hello\", use_daemon=True, session=None)\n+\n+ assert mock_call.call_count == 2\n+ assert mock_call.call_args_list[0].args[0] == \"focus search_input\"\n+ assert mock_call.call_args_list[1].args[0] == \"type hello\"\n+\n+\n+def test_type_text_raises_with_empty_path():\n+ with pytest.raises(ValueError, match=\"input path is required\"):\n+ backend.type_text(\"\", \"text\", session=_make_session())\n+ with pytest.raises(ValueError, match=\"input path is required\"):\n+ backend.type_text(\"/\", \"text\", session=_make_session())\n+\n+\n+def test_type_text_rejects_newline_in_text():\n+ \"\"\"``\\\\n`` in text would inject a new DOMShell command — must raise.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\nline2\")\n+\n+\n+def test_type_text_rejects_carriage_return_in_text():\n+ \"\"\"``\\\\r`` is just as dangerous as ``\\\\n`` for DOMShell's line splitter.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"search_input\", \"line1\\rline2\")\n+\n+\n+def test_type_text_rejects_newline_in_path():\n+ \"\"\"A newline in the path argument also injects — guard both fields.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.type_text(\"input\\nclick /admin\", \"anything\")\n+\n+\n+# ── grep: newline guard on rooted multi-step path ─────────────────────\n+\n+\n+def test_grep_rejects_newline_in_path():\n+ \"\"\"Rooted grep interpolates path into a multi-line cd/grep/cd — reject newlines.\"\"\"\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\\nclick /admin\", prev=\"/\")\n+\n+\n+def test_grep_rejects_newline_in_pattern():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\\nclick /admin\", path=\"/main\", prev=\"/\")\n+\n+\n+def test_grep_rejects_hyphen_prefixed_pattern():\n+ \"\"\"DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ so the grep wrapper can't pass hyphen-prefixed search strings as\n+ patterns. The wrapper raises ValueError with a clear message so\n+ users see the limitation immediately rather than getting DOMShell's\n+ generic Usage reply. Real fix needs upstream parseArgs ``--``\n+ support; tracked upstream. (@yuh-yang R3 blocker 3, Path B.)\n+ \"\"\"\n+ with pytest.raises(ValueError, match=\"patterns starting with '-'\"):\n+ backend.grep(\"-disabled\")\n+ with pytest.raises(ValueError, match=\"patterns starting with '-'\"):\n+ backend.grep(\"--content\")\n+\n+\n+def test_grep_rejects_newline_in_prev():\n+ with pytest.raises(ValueError, match=\"newline\"):\n+ backend.grep(\"Login\", path=\"/main\", prev=\"/\\nclick /admin\")\n+\n+\n+# ── Centralized newline guard in _q ──────────────────────────────────\n+#\n+# The per-wrapper _assert_single_line calls above cover type_text and\n+# rooted grep with field-named error messages. The newline check inside\n+# _q itself catches the same class of injection for every OTHER wrapper\n+# that flows user input through the quoting layer (open_url, click, cd,\n+# cat, unrooted grep, etc.) — without needing a per-call guard at each\n+# site.\n+\n+\n+def test_q_rejects_line_feeds():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\nbar\")\n+\n+\n+def test_q_rejects_carriage_returns():\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend._q(\"foo\\rbar\")\n+\n+\n+def test_q_accepts_normal_strings():\n+ \"\"\"Plain strings pass through to shlex.quote unchanged.\"\"\"\n+ assert backend._q(\"simple\") == \"simple\"\n+ assert backend._q(\"hello world\") == \"'hello world'\"\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_unrooted_grep_pattern_rejects_newlines(mock_call):\n+ \"\"\"The unrooted grep path was not field-guarded — _q catches it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.grep(\"evil\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_open_url_rejects_newlines(mock_call):\n+ \"\"\"open_url has no per-call _assert_single_line — _q must catch it.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.open_url(\"https://example.com\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_click_rejects_newlines(mock_call):\n+ \"\"\"click is covered structurally by _q without a per-call guard.\"\"\"\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.click(\"/main/button[0]\\nclick /admin\")\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_cd_rejects_newlines(mock_call):\n+ mock_call.return_value = {}\n+ with pytest.raises(ValueError, match=\"[Nn]ewline\"):\n+ backend.cd(\"/main\\nclick /admin\")\n+\n+\n+# ── DOMShell lane persistence across _call_execute calls ─────────────\n+#\n+# DOMShell 2.x assigns a fresh lane (Chrome tab-group) to every new MCP\n+# session. In non-daemon mode each _call_execute opens its own stdio\n+# ClientSession, so without explicit group_id every command would land\n+# in a brand-new lane and lose browser state from the previous call.\n+# The fix: parse the trailing \"[lane: <id>]\" marker DOMShell appends to\n+# each reply, store it on the harness Session, and pass group_id=<id>\n+# on every subsequent call.\n+\n+\n+def _make_session(\n+ working_dir: str = \"/\",\n+ daemon_mode: bool = False,\n+ lane_id=None,\n+):\n+ \"\"\"Build a minimal session fixture compatible with the backend's\n+ ``getattr``-style access (working_dir, daemon_mode, domshell_lane_id).\"\"\"\n+ return SimpleNamespace(\n+ working_dir=working_dir,\n+ daemon_mode=daemon_mode,\n+ domshell_lane_id=lane_id,\n+ )\n+\n+\n+def _make_result(text: str):\n+ \"\"\"Build a fake CallToolResult whose ``content[0].text`` is ``text``.\"\"\"\n+ return SimpleNamespace(content=[SimpleNamespace(text=text)])\n+\n+\n+# ── _extract_lane_id ────────────────────────────────────────────────\n+\n+\n+def test_extract_lane_id_parses_trailing_marker():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: 12345]\")) == \"12345\"\n+\n+\n+def test_extract_lane_id_handles_trailing_whitespace():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: lane-abc]\\n\")) == \"lane-abc\"\n+\n+\n+def test_extract_lane_id_ignores_shared_marker():\n+ \"\"\"`[lane: shared]` is DOMShell's no-isolation sentinel — must not pin to it.\"\"\"\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\\n[lane: shared]\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_when_marker_absent():\n+ assert backend._extract_lane_id(_make_result(\"✓ ls done\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_for_empty_text():\n+ assert backend._extract_lane_id(_make_result(\"\")) is None\n+\n+\n+def test_extract_lane_id_returns_none_when_content_missing():\n+ assert backend._extract_lane_id(SimpleNamespace()) is None\n+\n+\n+# ── lane capture + propagation ──────────────────────────────────────\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_first_call_passes_wrapper_signature_and_captures_lane(mock_call):\n+ \"\"\"A session with no stored lane: the wrapper passes (command,\n+ use_daemon, session=sess) into ``_call_execute``; the wire-format\n+ ``group_id`` selection (``\"new\"`` for non-daemon first calls,\n+ ``\"shared\"`` for daemon-mode-no-session) happens inside\n+ ``_call_execute`` itself and is covered by the dedicated\n+ wire-payload tests below. This test only asserts the wrapper-level\n+ call signature plus the ``_capture_lane`` parser hookup.\n+ \"\"\"\n+ sess = Session() # domshell_lane_id starts as None\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 12345]\")\n+\n+ backend.click(\"submit_btn\", session=sess)\n+\n+ # The session= kwarg the wrapper passes is the Session object itself;\n+ # _call_execute is responsible for translating session.domshell_lane_id\n+ # into the wire-format group_id. We only assert the call signature here.\n+ assert mock_call.call_args == call(\"click submit_btn\", False, session=sess)\n+ # _call_execute is mocked, so we exercise _capture_lane directly to\n+ # verify the parser hookup that the real _call_execute would do.\n+ backend._capture_lane(sess, mock_call.return_value)\n+ assert sess.domshell_lane_id == \"12345\"\n+\n+\n+def test_capture_lane_updates_session():\n+ sess = Session()\n+ backend._capture_lane(sess, _make_result(\"✓\\n[lane: lane-XYZ]\"))\n+ assert sess.domshell_lane_id == \"lane-XYZ\"\n+\n+\n+def test_capture_lane_no_op_when_session_is_none():\n+ \"\"\"Direct backend callers without a session must not crash.\"\"\"\n+ backend._capture_lane(None, _make_result(\"✓\\n[lane: 12345]\")) # no exception\n+\n+\n+def test_capture_lane_no_op_when_marker_missing():\n+ sess = Session()\n+ sess.domshell_lane_id = \"preexisting\"\n+ backend._capture_lane(sess, _make_result(\"✓ done\"))\n+ # No marker → don't clobber the previously-captured lane.\n+ assert sess.domshell_lane_id == \"preexisting\"\n+\n+\n+def test_capture_lane_ignores_shared_marker():\n+ sess = Session()\n+ sess.domshell_lane_id = \"preexisting\"\n+ backend._capture_lane(sess, _make_result(\"✓\\n[lane: shared]\"))\n+ assert sess.domshell_lane_id == \"preexisting\"\n+\n+\n+# ── End-to-end: lane reuse on subsequent calls ───────────────────────\n+\n+\n+def test_call_execute_includes_group_id_when_lane_is_set():\n+ \"\"\"When session.domshell_lane_id is set, _call_execute sends it as group_id.\n+\n+ We bypass the stdio_client / ClientSession plumbing entirely by patching\n+ them — what we want to assert is the arguments dict that gets passed to\n+ ``call_tool``.\n+ \"\"\"\n+ sess = Session()\n+ sess.domshell_lane_id = \"lane-7\"\n+\n+ fake_tool = AsyncMock(return_value=_make_result(\"✓\\n[lane: lane-7]\"))\n+\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.__aenter__.return_value = fake_mcp_session\n+ fake_mcp_session.__aexit__.return_value = None\n+ fake_mcp_session.initialize = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ fake_stdio = AsyncMock()\n+ fake_stdio.__aenter__.return_value = (object(), object())\n+ fake_stdio.__aexit__.return_value = None\n+\n+ with patch.object(backend, \"stdio_client\", return_value=fake_stdio), \\\n+ patch.object(backend, \"ClientSession\", return_value=fake_mcp_session), \\\n+ patch.object(backend, \"_build_server_args\", return_value=[]):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", session=sess))\n+\n+ name, arguments = fake_tool.call_args.args\n+ assert name == \"domshell_execute\"\n+ assert arguments == {\"command\": \"ls /\", \"group_id\": \"lane-7\"}\n+\n+\n+def test_call_execute_passes_group_id_new_when_lane_is_none():\n+ \"\"\"First-call shape: no stored lane → ``group_id=\"new\"``; DOMShell\n+ creates an isolated lane and returns the id, which we capture for\n+ next time.\n+\n+ Migration note (PR #308 follow-up to DOMShell 2.0.2): we used to omit\n+ ``group_id`` on the first call entirely, which DOMShell 2.x mapped\n+ to a fresh lane silently. 2.0.2 deprecated that path — omitting now\n+ emits a [DEPRECATION] warning on every reply (will be a hard error\n+ in 3.0.0). Passing ``\"new\"`` makes the intent explicit and silences\n+ the warning.\n+ \"\"\"\n+ sess = Session() # lane is None\n+ fake_tool = AsyncMock(return_value=_make_result(\"✓\\n[lane: brand-new]\"))\n+\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.__aenter__.return_value = fake_mcp_session\n+ fake_mcp_session.__aexit__.return_value = None\n+ fake_mcp_session.initialize = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ fake_stdio = AsyncMock()\n+ fake_stdio.__aenter__.return_value = (object(), object())\n+ fake_stdio.__aexit__.return_value = None\n+\n+ with patch.object(backend, \"stdio_client\", return_value=fake_stdio), \\\n+ patch.object(backend, \"ClientSession\", return_value=fake_mcp_session), \\\n+ patch.object(backend, \"_build_server_args\", return_value=[]):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", session=sess))\n+\n+ arguments = fake_tool.call_args.args[1]\n+ assert arguments.get(\"group_id\") == \"new\"\n+ # The auto-assigned lane gets captured for next time.\n+ assert sess.domshell_lane_id == \"brand-new\"\n+\n+\n+def test_call_execute_daemon_no_session_first_call_passes_new_and_captures_lane():\n+ \"\"\"Daemon mode + no session, first call: passes ``group_id=\"new\"``\n+ and captures the lane id from the response into the module-level\n+ ``_daemon_lane_id`` for subsequent calls. Replaces the previous\n+ ``\"shared\"`` behavior (commit 99d1182) per @yuh-yang R3 blocker 2.\n+\n+ The R2 \"shared\" branch claimed per-connection-default stickiness\n+ that holds when the persistent daemon connection is alive but\n+ breaks in the fall-back spawn path (each call gets its own\n+ per-MCP-session default lane). The captured-id approach works\n+ consistently across both paths because Chrome tab-group ids\n+ persist at the browser level, regardless of MCP session.\n+ \"\"\"\n+ # Reset module state (other tests may have populated it).\n+ backend._daemon_lane_id = None\n+\n+ try:\n+ fake_tool = AsyncMock(\n+ return_value=_make_result(\"✓\\n[lane: daemon-captured-99]\")\n+ )\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ with patch.object(backend, \"_daemon_session\", fake_mcp_session):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", use_daemon=True, session=None))\n+\n+ name, arguments = fake_tool.call_args.args\n+ assert name == \"domshell_execute\"\n+ assert arguments.get(\"group_id\") == \"new\"\n+ assert backend._daemon_lane_id == \"daemon-captured-99\"\n+ finally:\n+ backend._daemon_lane_id = None\n+\n+\n+def test_call_execute_daemon_no_session_subsequent_calls_reuse_captured_lane():\n+ \"\"\"Once ``_daemon_lane_id`` is set, daemon-no-session calls pass\n+ that id as ``group_id`` instead of ``\"new\"`` — preserves browser\n+ state across calls regardless of whether the daemon's stdio is\n+ alive or whether we've fallen back to fresh spawns per call.\n+ Capture stays stable; no clobber on subsequent calls.\n+ \"\"\"\n+ backend._daemon_lane_id = \"preexisting-77\"\n+\n+ try:\n+ fake_tool = AsyncMock(\n+ return_value=_make_result(\"✓\\n[lane: preexisting-77]\")\n+ )\n+ fake_mcp_session = AsyncMock()\n+ fake_mcp_session.call_tool = fake_tool\n+\n+ with patch.object(backend, \"_daemon_session\", fake_mcp_session):\n+ import asyncio as _aio\n+ _aio.run(backend._call_execute(\"ls /\", use_daemon=True, session=None))\n+\n+ name, arguments = fake_tool.call_args.args\n+ assert arguments.get(\"group_id\") == \"preexisting-77\"\n+ # Capture stays the same — no clobber on subsequent calls.\n+ assert backend._daemon_lane_id == \"preexisting-77\"\n+ finally:\n+ backend._daemon_lane_id = None\n+\n+\n+def test_distinct_sessions_have_isolated_lanes():\n+ \"\"\"Two sessions track lanes independently — no cross-contamination.\"\"\"\n+ s1 = Session()\n+ s2 = Session()\n+ backend._capture_lane(s1, _make_result(\"✓\\n[lane: lane-A]\"))\n+ backend._capture_lane(s2, _make_result(\"✓\\n[lane: lane-B]\"))\n+ assert s1.domshell_lane_id == \"lane-A\"\n+ assert s2.domshell_lane_id == \"lane-B\"\n+\n+\n+# ── Keyword-only enforcement on session= ─────────────────────────────\n+#\n+# Only ``session`` is keyword-only; ``use_daemon`` stays positional so\n+# pre-2.0.0 callers like ``ls(\"/\", True)`` keep working. ``grep`` is a\n+# deliberate exception (fully keyword-only after the round-1 review).\n+\n+\n+def test_session_is_keyword_only_on_click():\n+ \"\"\"Trailing positional `None` is interpreted as a 3rd positional arg\n+ that the wrapper doesn't accept — must raise TypeError.\"\"\"\n+ with pytest.raises(TypeError):\n+ backend.click(\"submit_btn\", False, None) # type: ignore[misc]\n+\n+\n+def test_session_is_keyword_only_on_ls():\n+ with pytest.raises(TypeError):\n+ backend.ls(\"/\", False, None) # type: ignore[misc]\n+\n+\n+def test_session_is_keyword_only_on_type_text():\n+ with pytest.raises(TypeError):\n+ backend.type_text(\"input\", \"hello\", False, None) # type: ignore[misc]\n+\n+\n+def test_session_is_keyword_only_on_open_url():\n+ with pytest.raises(TypeError):\n+ backend.open_url(\"https://example.com\", False, None) # type: ignore[misc]\n+\n+\n+# ── Positional `use_daemon` stays valid ──────────────────────────────\n+#\n+# These guard against accidentally pulling ``use_daemon`` behind the ``*``\n+# in the future. Pre-2.0.0 calls written as ``ls(\"/\", True)`` must not\n+# regress to ``TypeError``.\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_ls(mock_call):\n+ mock_call.return_value = _make_result(\"[lane: 1]\")\n+ backend.ls(\"/\", True) # use_daemon=True positionally\n+ # Absolute `/` with no session → 3-call sequence, use_daemon=True\n+ # flows through all three calls.\n+ assert mock_call.call_args_list == [\n+ call(\"cd %here%\", True, session=None),\n+ call(\"ls\", True, session=None),\n+ call(\"cd %here%\", True, session=None),\n+ ]\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_click(mock_call):\n+ mock_call.return_value = {}\n+ backend.click(\"submit_btn\", True)\n+ assert mock_call.call_args == call(\"click submit_btn\", True, session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_reload(mock_call):\n+ mock_call.return_value = {}\n+ backend.reload(True)\n+ assert mock_call.call_args == call(\"refresh\", True, session=None)\n+\n+\n+@patch.object(backend, \"_call_execute\", new_callable=AsyncMock)\n+def test_use_daemon_positional_on_type_text(mock_call):\n+ \"\"\"Positional ``use_daemon`` flows through both halves of the split.\n+\n+ type_text now requires a session, so pass one explicitly.\n+ \"\"\"\n+ sess = _make_session(working_dir=\"/\")\n+ mock_call.return_value = _make_result(\"✓\\n[lane: 1]\")\n+ backend.type_text(\"input\", \"hello\", True, session=sess)\n+ # Two calls (focus then type), both with use_daemon=True positionally.\n+ assert mock_call.call_args_list == [\n+ call(\"focus input\", True, session=sess),\n+ call(\"type hello\", True, session=sess),\n+ ]\n"},{"comment":"**<sub><sub></sub></sub> Pass hyphen-prefixed grep patterns as patterns**\n\nWhen the search text starts with `-` (for example `fs grep -disabled` or `backend.grep(\"--content\")`), this builds `grep -r -disabled`, so DOMShell's grep parser can interpret the user pattern as another option instead of the pattern; DOMShell documents grep as bash-like with options before the pattern (e.g. `grep -r --content \"sign up\"`), and GNU grep similarly calls out `-e` for patterns beginning with `-`. Use an explicit pattern delimiter/form such as `grep -r -e <pattern>` (or `--` if DOMShell supports it) here and in the rooted grep path so arbitrary search strings keep the old structured-tool behavior.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +626,501 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"cat: an element name is required — cannot cat the tab root. \"\n+ \"Use `ls` to list the root's children, or pass a specific name.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Preserve no-arg cat at the root**\n\nWhen the session is at its default/root working directory, `fs cat` with no path flows through `read_element()` as `backend.cat(\"/\")`, so this new guard always raises instead of reading the current element. The CLI still advertises `fs cat [path]` and the core deliberately uses `session.working_dir` when the path is omitted, so users who run `page open …` followed by `fs cat` now get an error before DOMShell is called; allow the root target here or adjust the no-arg flow to avoid passing `/`.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +637,501 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"cat: an element name is required — cannot cat the tab root. \"\n+ \"Use `ls` to list the root's children, or pass a specific name.\"\n+ )","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"The docs describe behavior that doesn’t match the implementation: (1) the backend no longer uses `group_id=\"shared\"` (it uses `\"new\"` + captured lane ids), and (2) several absolute-path operations are implemented as multiple separate `_call_execute` calls (split-and-check), not as a single multi-line `domshell_execute` call. Please update this section/table to reflect the actual wire behavior (separate calls + lane sharing via `session.domshell_lane_id` / `_daemon_lane_id`) so HARNESS.md remains a reliable operator reference.","path":"browser/agent-harness/HARNESS.md","hunk":"@@ -37,30 +37,55 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"shared\"` and `group_id=\"new\"` keywords introduced in 2.0.2 to\n+declare lane intent explicitly (silences the deprecation warning that 2.0.2\n+added for omitted `group_id`; will become a hard error in DOMShell 3.0.0).","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/HARNESS.md b/browser/agent-harness/HARNESS.md\nindex 7275a41a5a..2cd1ade02a 100644\n--- a/browser/agent-harness/HARNESS.md\n+++ b/browser/agent-harness/HARNESS.md\n@@ -37,30 +37,61 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"new\"` to declare lane intent explicitly on the first call of\n+each session and reuses the captured lane id on subsequent calls (silences\n+the deprecation warning that 2.0.2 added for omitted `group_id`; will\n+become a hard error in DOMShell 3.0.0). For direct daemon-mode callers\n+without a harness `Session`, the same scheme runs at module level — the\n+first call captures a lane id into `_daemon_lane_id` and subsequent calls\n+reuse it, preserving browser state across daemon-mode no-session calls\n+(see `domshell_backend.py`'s `_daemon_lane_id` declaration for the\n+stale-lane failure mode).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |\n+| `page open <url>` | `open <url>` |\n+| `page reload` | `refresh` |\n+| `page back` | `back` |\n+| `page forward` | `forward` |\n+\n+`<restore>` resolves to `cd %here%/<harness-working-dir>` (or `cd %here%`\n+when the harness is at the tab root) so the lane's cwd ends up where\n+the harness expects.\n \n ## Key Design Decisions\n \n"},{"comment":"The docs describe behavior that doesn’t match the implementation: (1) the backend no longer uses `group_id=\"shared\"` (it uses `\"new\"` + captured lane ids), and (2) several absolute-path operations are implemented as multiple separate `_call_execute` calls (split-and-check), not as a single multi-line `domshell_execute` call. Please update this section/table to reflect the actual wire behavior (separate calls + lane sharing via `session.domshell_lane_id` / `_daemon_lane_id`) so HARNESS.md remains a reliable operator reference.","path":"browser/agent-harness/HARNESS.md","hunk":"@@ -37,30 +37,55 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"shared\"` and `group_id=\"new\"` keywords introduced in 2.0.2 to\n+declare lane intent explicitly (silences the deprecation warning that 2.0.2\n+added for omitted `group_id`; will become a hard error in DOMShell 3.0.0).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/HARNESS.md b/browser/agent-harness/HARNESS.md\nindex 7275a41a5a..2cd1ade02a 100644\n--- a/browser/agent-harness/HARNESS.md\n+++ b/browser/agent-harness/HARNESS.md\n@@ -37,30 +37,61 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\n \n ### Installation\n \n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\n+`group_id=\"new\"` to declare lane intent explicitly on the first call of\n+each session and reuses the captured lane id on subsequent calls (silences\n+the deprecation warning that 2.0.2 added for omitted `group_id`; will\n+become a hard error in DOMShell 3.0.0). For direct daemon-mode callers\n+without a harness `Session`, the same scheme runs at module level — the\n+first call captures a lane id into `_daemon_lane_id` and subsequent calls\n+reuse it, preserving browser state across daemon-mode no-session calls\n+(see `domshell_backend.py`'s `_daemon_lane_id` declaration for the\n+stale-lane failure mode).\n+\n ```bash\n-# Verify DOMShell is available\n-npx @apireno/domshell --version\n+npx @apireno/domshell --version # should report 2.0.2 or higher\n \n # Install Chrome extension\n # https://chromewebstore.google.com/detail/domshell\n ```\n \n-### MCP Tools\n-\n-DOMShell exposes these MCP tools:\n-\n-| Tool | Description | CLI Command |\n-|------|-------------|-------------|\n-| `domshell_ls` | List directory contents | `fs ls` |\n-| `domshell_cd` | Change directory | `fs cd` |\n-| `domshell_cat` | Read element content | `fs cat` |\n-| `domshell_grep` | Search for pattern | `fs grep` |\n-| `domshell_click` | Click element | `act click` |\n-| `domshell_type` | Type text | `act type` |\n-| `domshell_open` | Navigate to URL | `page open` |\n-| `domshell_reload` | Reload page | `page reload` |\n-| `domshell_back` | Navigate back | `page back` |\n-| `domshell_forward` | Navigate forward | `page forward` |\n+The standard `npx @apireno/domshell` invocation pulls the latest published\n+version automatically; no manual pinning is required.\n+\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool. The harness targets\n+this consolidated tool, so no opt-in `--granular` server flag is required.\n+\n+### MCP Tool\n+\n+DOMShell 2.0.2+ exposes a single MCP tool:\n+\n+| Tool | Description |\n+|------|-------------|\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\n+\n+The harness builds command strings from the public CLI commands. Harness\n+absolute paths (leading `/`) are anchored at the tab root via\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\n+are passed through unchanged.\n+\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\n+|--------------------------------|--------------------------------------------|\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |\n+| `page open <url>` | `open <url>` |\n+| `page reload` | `refresh` |\n+| `page back` | `back` |\n+| `page forward` | `forward` |\n+\n+`<restore>` resolves to `cd %here%/<harness-working-dir>` (or `cd %here%`\n+when the harness is at the tab root) so the lane's cwd ends up where\n+the harness expects.\n \n ## Key Design Decisions\n \n"},{"comment":"This docstring claims the rooted grep path is executed as a single multi-line command, but the implementation below performs a split-and-check sequence across three separate `_call_execute` calls (anchor → grep → restore) with an error short-circuit after the anchor. Please update the docstring to match the actual behavior and rationale (lane consistency via `session`/daemon, and halting on anchor failure to avoid wrong-scope matches).","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +660,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"Several wrappers now call `asyncio.run(...)` multiple times per operation (e.g., `ls` absolute is 3x; `type_text` absolute is up to 4x). Even when keeping the split-and-check semantics, this adds repeated event-loop creation/teardown overhead. Consider refactoring each wrapper to run a single `asyncio.run()` around an inner async function that awaits multiple `_call_execute(...)` calls in sequence; this preserves behavior while reducing overhead and simplifying any future conversion to async-native APIs.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -223,192 +660,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_daemon_lane_id` is a module-level mutable global that can be read/written by concurrent callers of `_call_execute` (e.g., overlapping tasks/threads in daemon mode without a session). Without synchronization, concurrent “first call” paths can race and clobber/flip the captured lane. If concurrent use is possible in this harness, protect `_daemon_lane_id` updates (and potentially `_daemon_session` usage) with an async lock or otherwise serialize daemon-mode calls.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n \n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_daemon_lane_id` is a module-level mutable global that can be read/written by concurrent callers of `_call_execute` (e.g., overlapping tasks/threads in daemon mode without a session). Without synchronization, concurrent “first call” paths can race and clobber/flip the captured lane. If concurrent use is possible in this harness, protect `_daemon_lane_id` updates (and potentially `_daemon_session` usage) with an async lock or otherwise serialize daemon-mode calls.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n \n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_daemon_lane_id` is a module-level mutable global that can be read/written by concurrent callers of `_call_execute` (e.g., overlapping tasks/threads in daemon mode without a session). Without synchronization, concurrent “first call” paths can race and clobber/flip the captured lane. If concurrent use is possible in this harness, protect `_daemon_lane_id` updates (and potentially `_daemon_session` usage) with an async lock or otherwise serialize daemon-mode calls.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n \n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ if use_daemon and session is None and _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_extract_lane_id` duplicates the text-concatenation logic already implemented in `_extract_text`. To reduce drift risk (e.g., handling additional content types later), consider having `_extract_lane_id` call `_extract_text(result)` and then run the lane regex over that text.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_extract_lane_id` duplicates the text-concatenation logic already implemented in `_extract_text`. To reduce drift risk (e.g., handling additional content types later), consider having `_extract_lane_id` call `_extract_text(result)` and then run the lane regex over that text.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"`_extract_lane_id` duplicates the text-concatenation logic already implemented in `_extract_text`. To reduce drift risk (e.g., handling additional content types later), consider having `_extract_lane_id` call `_extract_text(result)` and then run the lane regex over that text.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"This log line drops the stack trace, which can make daemon failure diagnosis harder. Consider logging with exception context (e.g., using `log.exception(...)` or `log.warning(..., exc_info=True)`) while keeping the message the same.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n \n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ if use_daemon and session is None and _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ )","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Surface parsed ls/grep errors to non-JSON CLI**\n\nWhen DOMShell returns an error for `ls` or `grep` (for example `fs ls /missing` or a rooted grep whose anchor fails), this parser now returns only `{\"error\": ..., \"output\": ...}`. The non-JSON branches in `browser_cli.py` still read `result.get(\"entries\", [])` / `result.get(\"matches\", [])` and do not check `\"error\"`, so these failures are displayed as “No elements” or “No matches” instead of the actual DOMShell error; include the expected empty collection keys on errors or update those CLI branches to handle the parsed error shape.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +140,431 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"},{"comment":"**<sub><sub></sub></sub> Parse reusable paths from ls output**\n\nWhen DOMShell 2 emits its normal display lines such as `[d] article (article) → ./main/article/`, this parser stores that whole line as `entries[].path` instead of the actual element path. The JSON contract in the browser README/skill promises reusable paths like `/main`, and agents/scripts can reasonably feed `entries[0][\"path\"]` back into `fs cd`, `cat`, or `act click`; with the raw display line those follow-up commands target an invalid path. Please extract the name/role/path columns from DOMShell's line format rather than duplicating the raw line into `path`.\n\nUseful? React with 👍 / 👎.","path":"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py","hunk":"@@ -110,33 +148,436 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}","resolving_sha":"a87647e07ce6af1b3e94d8b4dce8d3b40e760489","resolving_diff":"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\nindex eafc25767b..674f63809d 100644\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\n@@ -10,16 +10,28 @@\n \n DOMShell GitHub: https://github.com/apireno/DOMShell\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\n+\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\n+per-command tools to a single `domshell_execute` tool that accepts a\n+shell-style command string (multi-line supported). This wrapper targets\n+that single tool.\n \"\"\"\n \n import asyncio\n+import logging\n import os\n+import re\n+import shlex\n import subprocess\n import shutil\n+import threading\n from typing import Any, Optional\n from mcp import ClientSession, StdioServerParameters\n from mcp.client.stdio import stdio_client\n \n+\n+log = logging.getLogger(__name__)\n+\n # DOMShell MCP server command\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\n # Configure via environment variables:\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\n _daemon_write: Optional[Any] = None\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\n \n+# Module-level lane id captured from the first daemon-mode-no-session\n+# call. Reused on every subsequent daemon-no-session call so direct\n+# wrappers like `open_url(use_daemon=True)` followed by\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\n+# of whether the daemon's persistent stdio connection is currently\n+# alive or whether we've fallen back to spawning a fresh ClientSession\n+# per call. The captured id is a numeric Chrome tab-group id, which\n+# persists at the browser level even across MCP session boundaries —\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\n+# spawn (or a still-living daemon) created.\n+#\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\n+# group this id points to, subsequent calls will surface DOMShell's\n+# \"Error: no lane 'A'\" with its own recovery guidance. We don't\n+# auto-recover here — same shape as `session.domshell_lane_id`\n+# pointing to a closed group. Restart the daemon (or reset this attr)\n+# to clear.\n+_daemon_lane_id: Optional[str] = None\n+\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\n+# callers of _call_execute in daemon mode without a session would\n+# otherwise race on the `is None` check below. Lock spans only the\n+# check + assignment (microsecond contention), not the MCP call.\n+# (Copilot R4 on commit 5790651.)\n+_daemon_lane_lock = threading.Lock()\n+\n \n def _check_npx() -> bool:\n \"\"\"Check if npx is available.\"\"\"\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\n \n Examples:\n >>> is_available()\n- (True, \"DOMShell v1.0.0 is available\")\n+ (True, \"DOMShell vX.Y.Z is available\") # whatever npx resolves to\n >>> is_available()\n (False, \"npx not found. Install Node.js from https://nodejs.org/\")\n \"\"\"\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\n return False, f\"DOMShell check failed: {e}\"\n \n \n-async def _call_tool(\n- tool_name: str,\n- arguments: dict,\n- use_daemon: bool = False\n+def _q(arg: str) -> str:\n+ \"\"\"Quote an argument for the DOMShell command parser (shell-style).\n+\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\n+ input *before* shell-style quote parsing, so a ``\\\\n`` or ``\\\\r``\n+ inside an otherwise-quoted argument still becomes a command\n+ separator. Enforcing the check here means every wrapper that flows\n+ user input through ``_q`` is protected by default, instead of\n+ relying on per-call ``_assert_single_line`` at each call site.\n+\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\n+ field-named error message (e.g. ``\"text: ...\"``) is more useful than\n+ the generic one raised here.\n+ \"\"\"\n+ if \"\\n\" in arg or \"\\r\" in arg:\n+ # Bound the echoed value so an arbitrarily large untrusted payload\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\n+ # in error messages or downstream logs / telemetry.\n+ preview = arg[:80] + (\"…\" if len(arg) > 80 else \"\")\n+ raise ValueError(\n+ \"Newline characters are not allowed in command arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ \"so a newline inside any wrapper input would inject additional \"\n+ f\"commands. Got ({len(arg)} chars): {preview!r}\"\n+ )\n+ return shlex.quote(arg)\n+\n+\n+# DOMShell 2.x appends a \"[lane: <id>]\" marker as the last line of every\n+# domshell_execute reply. We parse it out and store it on the harness\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\n+# the same Chrome tab-group (i.e. same browser state).\n+#\n+# The marker format is part of the DOMShell 2.x wire contract — see the\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\n+# for \"Multi-line semantics\" / \"lane marker\"). If DOMShell ever changes\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\n+# to follow.\n+_LANE_LINE = re.compile(r\"\\[lane:\\s*([^\\]\\s]+)\\s*\\]\\s*$\")\n+\n+\n+def _extract_lane_id(result: Any) -> Optional[str]:\n+ \"\"\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\n+\n+ Returns the lane id, or ``None`` if no marker is present, the text is\n+ empty, or the marker reports the default \"shared\" lane (which is\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\n+ \"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ if not text:\n+ return None\n+ m = _LANE_LINE.search(text.strip())\n+ if not m:\n+ return None\n+ lane = m.group(1).strip()\n+ if not lane or lane == \"shared\":\n+ return None\n+ return lane\n+\n+\n+def _capture_lane(session: Any, result: Any) -> None:\n+ \"\"\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\"\"\"\n+ if session is None:\n+ return\n+ lane = _extract_lane_id(result)\n+ if lane:\n+ session.domshell_lane_id = lane\n+\n+\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\n+ \"\"\"Translate a harness DOM path into ``(stripped, is_absolute)``.\n+\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\n+ keeps a per-lane cwd that persists between commands — so after\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\n+ against the drifted cwd as ``/main/main``. Wrong target.\n+\n+ The fix: distinguish *absolute* from *relative* harness paths so\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\n<op>\\\\ncd\n+ <restore>`` for the absolute case (anchoring at the tab root), and\n+ pass relative paths through unchanged (the lane cwd is the right\n+ reference for them).\n+\n+ Uses ``lstrip(\"/\")`` so accidental ``//main`` collapses to ``main``.\n+\n+ Examples:\n+ ``\"\"`` → ``(\"\", False)``\n+ ``\"/\"`` → ``(\"\", True)``\n+ ``\"/main\"`` → ``(\"main\", True)``\n+ ``\"//main\"`` → ``(\"main\", True)``\n+ ``\"/main/btn\"`` → ``(\"main/btn\", True)``\n+ ``\"main\"`` → ``(\"main\", False)``\n+ ``\"..\"`` → ``(\"..\", False)``\n+ \"\"\"\n+ # Newline guard at the translation boundary: absolute-path branches\n+ # interpolate `%here%/<translated>` without going through `_q`\n+ # (DOMShell's path-variable expander runs before quote parsing on\n+ # `cd`, so quoting would defeat it). Catching newlines here means\n+ # every wrapper that consumes the translated path is protected\n+ # against injection, even if the wrapper skips `_q`.\n+ if \"\\n\" in harness_path or \"\\r\" in harness_path:\n+ raise ValueError(\n+ \"Newline characters are not allowed in path arguments — \"\n+ \"DOMShell's domshell_execute treats them as command separators, \"\n+ f\"so a newline in a path would inject additional commands. \"\n+ f\"Got ({len(harness_path)} chars): \"\n+ f\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\"\n+ )\n+ if not harness_path:\n+ return \"\", False\n+ if harness_path.startswith(\"/\"):\n+ return harness_path.lstrip(\"/\"), True\n+ return harness_path, False\n+\n+\n+def _here_path(deeper: str) -> str:\n+ \"\"\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\n+\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\n+ the ``<deeper>`` portion survive the wrap correctly.\n+\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\n+ unchanged, so ``_here_path(\"main\")`` is still ``%here%/main``.\n+ \"\"\"\n+ return _q(f\"%here%/{deeper}\") if deeper else _q(\"%here%\")\n+\n+\n+def _restore_cwd_cmd(session: Any) -> str:\n+ \"\"\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\n+\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\n+ form) so after the wrapped operation the lane's cwd matches what the\n+ harness thinks it is. Without this restore, a wrapped operation\n+ against ``/`` would leave the lane parked at ``%here%`` even though\n+ the harness's ``working_dir`` is something like ``/main``.\n+\n+ The harness ``working_dir`` is always absolute in normal use, so the\n+ common output shape is ``cd %here%/<stripped>``. The relative\n+ branch is a defensive fallback for an unusual session shape.\n+ \"\"\"\n+ wd = getattr(session, \"working_dir\", None) or \"/\"\n+ stripped, is_abs = _translate_path(wd)\n+ if is_abs:\n+ return f\"cd {_here_path(stripped)}\"\n+ return f\"cd {_q(stripped)}\" if stripped else f\"cd {_here_path('')}\"\n+\n+\n+def _anchor_path_cmd(deeper: str = \"\") -> str:\n+ \"\"\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\n+\n+ The reusable anchor primitive for split-and-check wrapper patterns.\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\n+ first ``_call_execute``, then ``_is_error``-checks the result before\n+ running the operation. Used for the anchor and restore positions in\n+ the split-and-check pattern.\n+ \"\"\"\n+ return f\"cd {_here_path(deeper)}\"\n+\n+\n+def _require_session_for_split_check(\n+ wrapper: str, session: Any, use_daemon: bool,\n+) -> None:\n+ \"\"\"Raise if a split-and-check wrapper would lose lane consistency.\n+\n+ Split-and-check patterns (anchor → op → restore as separate\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\n+ lane. In daemon mode the persistent connection guarantees that\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\n+ to forward via ``group_id`` on each call. Without either, the\n+ anchor lands in lane A and the operation lands in lane B — same\n+ lane-isolation regression as round-5's first failure mode.\n+\n+ The general rule: any wrapper that issues multiple\n+ ``_call_execute`` calls whose correctness depends on shared lane\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\n+ absolute paths and ``grep`` rooted paths (both absolute and\n+ relative) in round 7.2. Centralizes the contract so future\n+ multi-call wrappers can call into the same check.\n+ \"\"\"\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ f\"{wrapper}: a session argument is required in non-daemon \"\n+ \"mode for rooted paths so the anchor cd and the operation \"\n+ \"share a DOMShell lane. Either pass a Session, use an \"\n+ \"unrooted form, or enable daemon mode.\"\n+ )\n+\n+\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\n+# Strip them before prefix-matching \"error\" so an ANSI-coloured error line\n+# isn't misread as success.\n+_ANSI_CSI_RE = re.compile(r\"\\x1b\\[[0-9;]*[A-Za-z]\")\n+\n+\n+def _is_error(result: Any) -> bool:\n+ \"\"\"Detect whether a ``domshell_execute`` result represents an error.\n+\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\n+ AND command-prefixed, e.g.:\n+\n+ * ``\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m``\n+ * ``\\\\x1b[31mfocus: No such element\\\\x1b[0m``\n+ * ``\\\\x1b[31mls: main: No such directory\\\\x1b[0m``\n+\n+ Note none of these start with the literal \"error\" — the earlier\n+ detection that ANSI-stripped first then checked ``startswith(\"error\")``\n+ silently failed every command-prefixed case, which silently regressed\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\n+ ``\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\n+ every error in red and uses different codes (e.g. ``\\\\x1b[32m``\n+ green) for success.\n+\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\n+ then the ANSI-red marker, with a final fallback to a stripped\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\n+ a transport layer) or that arrives without DOMShell's coloring.\n+ \"\"\"\n+ if hasattr(result, \"isError\") and result.isError:\n+ return True\n+ if isinstance(result, dict):\n+ if result.get(\"isError\") or result.get(\"error\"):\n+ return True\n+\n+ text = _extract_text(result)\n+ if not text:\n+ return False\n+\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\n+ # color code IS the signal, and the message that follows is\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\n+ # \"Error:\"-prefixed.\n+ if \"\\x1b[31m\" in text:\n+ return True\n+\n+ # Fallback: ANSI-stripped text with explicit \"Error:\" prefix.\n+ # Catches rarer non-colored errors and any input that arrives\n+ # pre-stripped.\n+ cleaned = _ANSI_CSI_RE.sub(\"\", text).strip().lower()\n+ if cleaned.startswith(\"error:\"):\n+ return True\n+\n+ return False\n+\n+\n+def _extract_text(result: Any) -> str:\n+ \"\"\"Concatenate ``content[*].text`` from a CallToolResult-like object.\"\"\"\n+ text = \"\"\n+ content = getattr(result, \"content\", None)\n+ if content:\n+ for c in content:\n+ piece = getattr(c, \"text\", None)\n+ if piece:\n+ text += piece\n+ return text\n+\n+\n+def _parse_execute_result(result: Any, command: str) -> dict:\n+ \"\"\"Translate a ``domshell_execute`` text response into the dict shape\n+ ``browser_cli.py`` and friends consume.\n+\n+ DOMShell 2.x returns text content over MCP (plus a trailing\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\n+ per-command tools, which returned structured dicts — so without\n+ this translator the harness throws ``AttributeError`` on\n+ ``result.get(\"entries\")`` / ``result.get(\"matches\")`` etc.\n+\n+ The shape contract per command (read off the CLI callers):\n+\n+ * ``ls`` → ``{\"entries\": [{\"name\", \"role\", \"path\"}, ...], \"raw\"}``\n+ * ``grep``→ ``{\"matches\": [...], \"raw\"}``\n+ * error → ``{\"error\": text, \"output\": text}`` (caller checks\n+ ``\"error\" in result`` before normal handling)\n+ * other → ``{\"output\": text}`` (CLI's ``output()`` / ``_print_dict``\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\n+ ``set_url`` step if ``\"url\"`` is absent, matching today's behavior)\n+\n+ This is a minimum-viable parser that satisfies the dict-key\n+ contract. Finer-grained parsing of element name / role / path\n+ columns can land as a follow-up once DOMShell's exact text format\n+ stabilizes — for now every line is plumbed through as the ``name``\n+ field (and the ``path`` field) so the CLI's table view still\n+ renders rather than crashing.\n+ \"\"\"\n+ text = _LANE_LINE.sub(\"\", _extract_text(result)).strip()\n+\n+ if _is_error(result):\n+ return {\"error\": text, \"output\": text}\n+\n+ if command == \"ls\":\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\n+ entries = [\n+ {\"name\": ln.strip(), \"role\": \"\", \"path\": ln.strip()}\n+ for ln in lines\n+ ]\n+ return {\"entries\": entries, \"raw\": text}\n+\n+ if command == \"grep\":\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\n+ return {\"matches\": matches, \"raw\": text}\n+\n+ if command in (\"back\", \"forward\", \"navigate\", \"open\"):\n+ # Navigation commands typically respond with a `URL: <url>`\n+ # (and often `Title: <title>`) line — extract both so\n+ # `page.go_back` / `page.go_forward`'s `\"url\" in result` guards\n+ # actually fire and `session.set_url` updates correctly. (Round\n+ # 7's parser made these guards permanently False; this is the\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\n+ # CLI display paths still work.\n+ nav: dict = {\"output\": text}\n+ url_match = re.search(r\"URL:\\s+(\\S+)\", text)\n+ if url_match:\n+ nav[\"url\"] = url_match.group(1)\n+ title_match = re.search(r\"Title:\\s+(.+?)(?:\\r?\\n|$)\", text)\n+ if title_match:\n+ nav[\"title\"] = title_match.group(1).strip()\n+ return nav\n+\n+ # cd / cat / click / focus / type / refresh all funnel through the\n+ # CLI's generic dict pretty-printer; an ``{\"output\": text}`` shape\n+ # is enough.\n+ return {\"output\": text}\n+\n+\n+def _assert_single_line(field: str, value: str) -> None:\n+ \"\"\"Reject newline characters in a user-supplied string.\n+\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\n`` or\n+ ``\\\\r`` inside an otherwise-quoted argument escapes the quoting and\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\n+ value that gets interpolated into a multi-line command string.\n+ \"\"\"\n+ if \"\\n\" in value or \"\\r\" in value:\n+ raise ValueError(\n+ f\"{field}: newline characters are not allowed (would be interpreted \"\n+ f\"as DOMShell command separators). Got: {value!r}\"\n+ )\n+\n+\n+async def _call_execute(\n+ command: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n ) -> Any:\n- \"\"\"Call a DOMShell MCP tool.\n+ \"\"\"Run a DOMShell command via the single `domshell_execute` MCP tool.\n \n Args:\n- tool_name: Name of the MCP tool (e.g., \"domshell_ls\", \"domshell_cd\")\n- arguments: Arguments to pass to the tool\n+ command: DOMShell command string. May contain newlines for multi-command\n+ execution — each line runs in order in the same shell state.\n use_daemon: If True, use persistent daemon connection (if available)\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\n+ forwarded as ``group_id`` (when set) and updated from the result\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\n+ for one-off direct calls that don't need cross-call state.\n \n Returns:\n Tool result as returned by MCP server\n@@ -128,15 +523,61 @@ async def _call_tool(\n Raises:\n RuntimeError: If MCP server is not available or tool call fails\n \"\"\"\n- global _daemon_session, _daemon_read, _daemon_write\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\n+\n+ arguments: dict[str, Any] = {\"command\": command}\n+ # Lane handling — three sources, in priority order:\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\n+ # state preserved across non-daemon spawn-per-call sequences).\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\n+ # → reuse the daemon-level captured id. Works whether the daemon's\n+ # stdio is alive (id reused on persistent connection) or dead\n+ # (fresh spawn joins the existing Chrome tab-group by id).\n+ # • Otherwise → group_id=\"new\". DOMShell creates a fresh isolated\n+ # lane and returns the id in the [lane: ...] marker, captured into\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\n+ #\n+ # The \"shared\" branch from the previous version of this code (commit\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\n+ # sticky across calls — true when the persistent daemon connection is\n+ # alive, but a lie in the fall-back spawn path where each call gets a\n+ # different per-MCP-session default lane. @yuh-yang's review of\n+ # b684732 flagged the inconsistency. The module-level capture path\n+ # below is consistent across both daemon-alive and daemon-dead.\n+ if session is not None and getattr(session, \"domshell_lane_id\", None):\n+ arguments[\"group_id\"] = session.domshell_lane_id\n+ elif use_daemon and _daemon_lane_id:\n+ arguments[\"group_id\"] = _daemon_lane_id\n+ else:\n+ arguments[\"group_id\"] = \"new\"\n \n if use_daemon and _daemon_session is not None:\n # Use persistent daemon connection\n try:\n- result = await _daemon_session.call_tool(tool_name, arguments)\n+ result = await _daemon_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # Daemon-level capture on first daemon-no-session call so\n+ # subsequent calls reuse the same lane regardless of whether\n+ # the daemon stays alive or we fall back to fresh spawns.\n+ # `is None` check moved INSIDE the lock to fix the\n+ # test-and-set race between concurrent callers.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n- # Daemon died, fall back to spawning new server\n+ # Daemon died — log diagnosability and fall back to spawning\n+ # a fresh server below. Silent swallow was making the daemon\n+ # failure mode invisible in user reports.\n+ log.warning(\n+ \"DOMShell daemon call failed, respawning per-command: %s\", e,\n+ exc_info=True,\n+ )\n await _stop_daemon()\n \n # Spawn new MCP server process\n@@ -147,9 +588,21 @@ async def _call_tool(\n \n try:\n async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- result = await session.call_tool(tool_name, arguments)\n+ async with ClientSession(read, write) as mcp_session:\n+ await mcp_session.initialize()\n+ result = await mcp_session.call_tool(\n+ \"domshell_execute\", arguments\n+ )\n+ _capture_lane(session, result)\n+ # See daemon-path capture above for rationale — same\n+ # logic applies on the fresh-spawn fall-back path,\n+ # including the lock-guarded test-and-set.\n+ if use_daemon and session is None:\n+ with _daemon_lane_lock:\n+ if _daemon_lane_id is None:\n+ captured = _extract_lane_id(result)\n+ if captured:\n+ _daemon_lane_id = captured\n return result\n except Exception as e:\n raise RuntimeError(\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\n return _daemon_session is not None\n \n \n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\n+#\n+# Each wrapper builds a shell-style command string and dispatches to\n+# `domshell_execute`. The public Python API is unchanged from the\n+# pre-2.0.0 per-tool wrappers.\n \n-def ls(path: str = \"/\", use_daemon: bool = False) -> dict:\n+def ls(path: str = \"/\", use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"List directory contents in the accessibility tree.\n \n Args:\n path: Path in accessibility tree (e.g., \"/\", \"/main\", \"/main/div[0]\")\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'entries' key containing list of accessible elements\n+ Dict shaped ``{\"entries\": [{\"name\": str, \"role\": \"\", \"path\": str}, ...],\n+ \"raw\": str}`` (or ``{\"error\": str, \"output\": str}`` on failure —\n+ wrappers reuse ``_parse_execute_result``'s contract).\n+\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\n+ ``ls`` output; directory entries currently include a trailing\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\n+ this round — structured role extraction will land alongside a\n+ finer column parser in the follow-up.\n \n Example:\n- >>> ls(\"/\")\n- {\"path\": \"/\", \"entries\": [{\"name\": \"main\", \"role\": \"landmark\", ...}]}\n+ >>> ls(\"/main\", session=session) # session required for absolute paths\n+ {\"entries\": [{\"name\": \"heading_1\", \"role\": \"\", \"path\": \"heading_1\"},\n+ {\"name\": \"div/\", \"role\": \"\", \"path\": \"div/\"},\n+ ...],\n+ \"raw\": \"heading_1\\\\ndiv/\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_ls\", {\"options\": path}, use_daemon))\n- return result\n-\n-\n-def cd(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ if is_absolute:\n+ _require_session_for_split_check(\"ls\", session, use_daemon)\n+ # Split-and-check: the anchor's success is load-bearing — if\n+ # cd fails, ls would run in the wrong cwd and produce\n+ # wrong-target results. Three separate _call_execute calls so\n+ # we can _is_error-gate after the anchor and skip the operation\n+ # cleanly. All share the persisted lane via session.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(translated), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"ls\")\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ # Best-effort restore — ls already ran; restore failure is\n+ # cosmetic (next harness cd corrects any drift).\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"ls\")\n+ if translated:\n+ op = asyncio.run(_call_execute(\n+ f\"ls {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ else:\n+ op = asyncio.run(_call_execute(\"ls\", use_daemon, session=session))\n+ return _parse_execute_result(op, \"ls\")\n+\n+\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Change directory in the accessibility tree.\n \n Args:\n path: Target path\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with 'path' key confirming current location\n+ Dict shaped ``{\"output\": str}`` on success, or\n+ ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ Note no ``\"path\"`` key — ``fs.change_directory`` falls back to\n+ the input ``path`` arg via ``result.get(\"path\", path)``, so the\n+ harness's ``working_dir`` ends up at the requested target. The\n+ ``output`` field carries DOMShell's raw confirmation text for\n+ display.\n \n Example:\n >>> cd(\"/main/div[0]\")\n- {\"path\": \"/main/div[0]\", \"element\": {...}}\n+ {\"output\": \"✓ Entered /main/div[0]\"}\n+ >>> cd(\"/missing\")\n+ {\"error\": \"cd: /missing: No such directory\",\n+ \"output\": \"cd: /missing: No such directory\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cd\", {\"path\": path}, use_daemon))\n- return result\n-\n-\n-def cat(path: str, use_daemon: bool = False) -> dict:\n+ translated, is_absolute = _translate_path(path)\n+ # cd is the one wrapper where the operation IS the new state — no\n+ # following operation needs the anchored cwd, so no split-and-check\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\n+ # the result is independent of the lane's current cwd.\n+ if is_absolute:\n+ command = _anchor_path_cmd(translated)\n+ elif translated:\n+ command = f\"cd {_q(translated)}\"\n+ else:\n+ # Bare/empty `cd` → back to tab root.\n+ command = _anchor_path_cmd(\"\")\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\n+ return _parse_execute_result(result, \"cd\")\n+\n+\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Read element content from the accessibility tree.\n \n Args:\n path: Path to element\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with element details including text, role, attributes\n \n Example:\n- >>> cat(\"/main/button[0]\")\n- {\"name\": \"Submit\", \"role\": \"button\", \"text\": \"Submit\", ...}\n+ >>> cat(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"button: Submit\\\\n...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_cat\", {\"name\": path}, use_daemon))\n- return result\n-\n-\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\n- \"\"\"Search for pattern in accessibility tree.\n-\n- Searches from the current working directory.\n+ translated, is_absolute = _translate_path(path)\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\n+ # converted that into a Python ValueError, which broke the\n+ # `fs.read_element(session, \"\")` fall-through to `session.working_dir`\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\n+ # `if (!targetName)` check and returns its standard Usage error.\n+ if is_absolute:\n+ _require_session_for_split_check(\"cat\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise run relative cat, restore. Anchor success is\n+ # load-bearing — without it cat resolves the relative path\n+ # against the wrong cwd.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+ op = asyncio.run(_call_execute(\n+ f\"cat {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"cat\")\n+\n+\n+def grep(\n+ pattern: str,\n+ *,\n+ path: str = \"\",\n+ prev: str = \"/\",\n+ use_daemon: bool = False,\n+ session: Any = None,\n+) -> dict:\n+ \"\"\"Search for pattern in the accessibility tree.\n+\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\n+ non-daemon mode opens a fresh stdio session that lands in its own\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\n+ the final line of the same command and runs even if ``grep`` errors —\n+ DOMShell's multi-line splitter continues past errors (see\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\n+\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\n+ breakage of callers written against the pre-migration positional\n+ signature ``grep(pattern, use_daemon)``.\n \n Args:\n pattern: Text pattern to search for\n+ path: Optional path to root the search at. If empty or \"/\", searches\n+ from the server-side current working directory.\n+ prev: Path to restore as cwd after the search. Used only when\n+ ``path`` is provided. Defaults to \"/\".\n use_daemon: Use persistent daemon connection if available\n \n Returns:\n Dict with 'matches' key containing list of matching elements\n \n Example:\n- >>> grep(\"Login\")\n- {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"]}\n+ >>> grep(\"Login\") # unrooted — session optional\n+ {\"matches\": [\"/main/button[0]\", \"/main/link[1]\"], \"raw\": \"...\"}\n+ >>> grep(\"Login\", path=\"/main\", session=session) # rooted → session required\n+ {\"matches\": [\"/main/button[0]\"], \"raw\": \"...\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\n- \"domshell_grep\",\n- {\"pattern\": pattern},\n- use_daemon\n+ _assert_single_line(\"pattern\", pattern)\n+\n+ # DOMShell's parseArgs treats any arg starting with \"-\" as a flag,\n+ # with no \"--\" end-of-options separator and no \"-e <pattern>\" form\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\n+ # kernel — neither survives parseArgs as a positional. Until\n+ # DOMShell adds \"--\" support in a future release, raise a clear\n+ # Python-side error so the user sees the limitation immediately\n+ # instead of getting DOMShell's generic \"Usage:\" reply.\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\n+ if pattern.startswith(\"-\"):\n+ raise ValueError(\n+ f\"grep: patterns starting with '-' are not supported by the \"\n+ f\"current DOMShell parser — it would parse {pattern!r} as a \"\n+ f\"flag rather than as the search pattern. Known limitation \"\n+ f\"tracked upstream; will be resolved when DOMShell's \"\n+ f\"parseArgs adds `--` end-of-options support. Workaround: \"\n+ f\"drop the leading '-' from the pattern if possible, or \"\n+ f\"wait for the upstream fix.\"\n+ )\n+ translated_path, path_abs = _translate_path(path)\n+ if not translated_path:\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\n+ # `-r` preserves the pre-migration semantic: the old\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\n+ # searches the cwd's immediate children, missing nested matches.\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"grep\")\n+\n+ # `path` was already newline-guarded by `_translate_path` above\n+ # (round 6's translation-boundary check) so the field-named\n+ # `_assert_single_line(\"path\", path)` we used to call here would be\n+ # dead. `prev`, however, is only translated in the relative branch\n+ # below — the absolute branch doesn't touch it. Keep the explicit\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\n+ # useful error regardless of which branch consumes it.\n+ _assert_single_line(\"prev\", prev)\n+\n+ # Both rooted branches (absolute and relative) issue 3 separate\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\n+ # all three landing in the same DOMShell lane. Check session here so\n+ # the requirement applies uniformly.\n+ _require_session_for_split_check(\"grep\", session, use_daemon)\n+\n+ # Split-and-check. Anchor success is load-bearing: if the cd\n+ # to the rooting path fails, grep would search against the wrong\n+ # cwd and produce wrong-scope matches.\n+ if path_abs:\n+ anchor_cmd = _anchor_path_cmd(translated_path)\n+ restore_cmd = _restore_cwd_cmd(session)\n+ else:\n+ translated_prev, prev_abs = _translate_path(prev)\n+ anchor_cmd = f\"cd {_q(translated_path)}\"\n+ if prev_abs:\n+ restore_cmd = _anchor_path_cmd(translated_prev)\n+ else:\n+ restore_cmd = (\n+ f\"cd {_q(translated_prev)}\"\n+ if translated_prev\n+ else _anchor_path_cmd(\"\")\n+ )\n+\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"grep\")\n+ # `-r` preserves the pre-migration recursive default (see unrooted\n+ # branch above for the full rationale).\n+ op = asyncio.run(_call_execute(\n+ f\"grep -r {_q(pattern)}\", use_daemon, session=session,\n ))\n- return result\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\n+ return _parse_execute_result(op, \"grep\")\n \n \n-def click(path: str, use_daemon: bool = False) -> dict:\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Click an element in the accessibility tree.\n \n Args:\n path: Path to element to click\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with action result\n \n Example:\n- >>> click(\"/main/button[0]\")\n- {\"action\": \"click\", \"path\": \"/main/button[0]\", \"status\": \"success\"}\n+ >>> click(\"/main/button[0]\", session=session) # required for absolute paths\n+ {\"output\": \"✓ Clicked\\\\n[lane: 1]\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_click\", {\"name\": path}, use_daemon))\n- return result\n+ translated, is_absolute = _translate_path(path)\n+ if not translated:\n+ raise ValueError(\n+ \"click: an element name is required — cannot click the tab root.\"\n+ )\n+ if is_absolute:\n+ _require_session_for_split_check(\"click\", session, use_daemon)\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\n+ # otherwise click the relative path, restore. Anchor success is\n+ # load-bearing — clicking the wrong element if cwd has drifted\n+ # could trigger an unintended action.\n+ anchor = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor):\n+ return _parse_execute_result(anchor, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n+ op = asyncio.run(_call_execute(\n+ f\"click {_q(translated)}\", use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(op, \"click\")\n \n \n-def open_url(url: str, use_daemon: bool = False) -> dict:\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate to a URL in Chrome.\n \n Args:\n url: URL to navigate to\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure.\n+\n+ ``url`` and ``title`` are extracted from the DOMShell response\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\n+ present when DOMShell emits those lines, omitted otherwise.\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\n+ ``session.set_url(url)`` from the input arg), but the same\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\n+ callers DO depend on ``\"url\" in result``.\n \n Example:\n >>> open_url(\"https://example.com\")\n- {\"url\": \"https://example.com\", \"status\": \"loaded\"}\n+ {\"output\": \"✓ Opened\\\\nURL: https://example.com\\\\nTitle: Example Domain\\\\n[lane: 1]\",\n+ \"url\": \"https://example.com\",\n+ \"title\": \"Example Domain\"}\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_open\", {\"url\": url}, use_daemon))\n- return result\n+ result = asyncio.run(\n+ _call_execute(f\"open {_q(url)}\", use_daemon, session=session)\n+ )\n+ return _parse_execute_result(result, \"open\")\n \n \n-def reload(use_daemon: bool = False) -> dict:\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Reload the current page.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n Dict with reload result\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_reload\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"refresh\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"refresh\")\n \n \n-def back(use_daemon: bool = False) -> dict:\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate back in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_back`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_back\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"back\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"back\")\n \n \n-def forward(use_daemon: bool = False) -> dict:\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\n \"\"\"Navigate forward in history.\n \n Args:\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with navigation result\n+ Dict shaped ``{\"output\": str, \"url\": str, \"title\": str}`` on\n+ success, or ``{\"error\": str, \"output\": str}`` on failure. ``url``\n+ and ``title`` are extracted from the response text via regex\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\n+ the response shape changes upstream — ``page.go_forward`` guards\n+ its ``session.set_url`` update on ``\"url\" in result``, so a\n+ missing URL silently skips the update.\n \"\"\"\n- result = asyncio.run(_call_tool(\"domshell_forward\", {}, use_daemon))\n- return result\n+ result = asyncio.run(_call_execute(\"forward\", use_daemon, session=session))\n+ return _parse_execute_result(result, \"forward\")\n \n \n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\n+def type_text(\n+ path: str,\n+ text: str,\n+ use_daemon: bool = False,\n+ *,\n+ session: Any = None,\n+) -> dict:\n \"\"\"Type text into an input element.\n \n- Focuses the element first (via domshell_focus), then types. Both operations\n- run in a single MCP session so that focus state is preserved.\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\n+ persisted lane id (via ``session``), so the focus state from the\n+ first call carries into the second.\n+\n+ Why split: DOMShell's multi-line splitter continues past per-line\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\n+ chains like ``cd / grep / cd back`` (the restore must always run)\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\n+ failed ``focus`` followed by a successful ``type`` would dispatch\n+ keys into whatever was previously focused (potentially a password\n+ field). Halting between focus and type prevents that.\n+\n+ Performance note: in non-daemon mode with an absolute path this\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\n+ so up to four ``npx`` server spawns per call. Relative paths use\n+ two calls; daemon mode reuses one persistent connection for the\n+ whole chain regardless of path form. The per-call overhead is\n+ accepted to keep the wrapper-level error semantics simple; a future\n+ refactor could share a single ``ClientSession`` across the chain\n+ (post-merge follow-up).\n \n Args:\n path: Path to input element\n text: Text to type\n use_daemon: Use persistent daemon connection if available\n+ session: Harness session whose DOMShell lane id is reused / updated\n \n Returns:\n- Dict with action result\n+ Dict with action result. If ``focus`` errors, returns the focus\n+ result without calling ``type``.\n+\n+ Raises:\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\n+ ``domshell_execute`` treats newlines as command separators, so\n+ an embedded newline would inject additional commands. Split\n+ into multiple ``type_text`` calls for multi-line input.\n \"\"\"\n- async def _focus_and_type():\n- global _daemon_session\n- if use_daemon and _daemon_session is not None:\n- await _daemon_session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await _daemon_session.call_tool(\"domshell_type\", {\"text\": text})\n-\n- server_params = StdioServerParameters(\n- command=DEFAULT_SERVER_CMD,\n- args=_build_server_args()\n+ _assert_single_line(\"path\", path)\n+ _assert_single_line(\"text\", text)\n+\n+ # In daemon mode both halves share the persistent `_daemon_session`\n+ # naturally — same MCP session means same DOMShell lane, no\n+ # group_id juggling needed. Only the non-daemon path requires\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\n+ # fresh stdio session that would land in its own lane otherwise.\n+ if session is None and not use_daemon:\n+ raise ValueError(\n+ \"type_text: a session argument is required in non-daemon mode \"\n+ \"so the focus and type calls share a DOMShell lane via group_id. \"\n+ \"(Daemon mode shares the persistent connection's lane \"\n+ \"automatically and doesn't need session.)\"\n )\n- async with stdio_client(server_params) as (read, write):\n- async with ClientSession(read, write) as session:\n- await session.initialize()\n- await session.call_tool(\"domshell_focus\", {\"name\": path})\n- return await session.call_tool(\"domshell_type\", {\"text\": text})\n \n- return asyncio.run(_focus_and_type())\n+ translated_path, is_absolute = _translate_path(path)\n+ if not translated_path:\n+ raise ValueError(\n+ \"type_text: an input path is required — cannot focus the tab root.\"\n+ )\n+\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\n+ # error so the restore always runs. Safety chains want the opposite:\n+ # halt on the first step's error so the second step doesn't dispatch\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\n+ # multi-line continue-on-error script) re-introduces the trap the\n+ # round-4 split was designed to prevent — the anchor's leading \"✓\"\n+ # text in the combined response masks the focus error, and `type`\n+ # would land in whatever was previously focused.\n+ #\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\n+ # (one-line `cd %here%`), check for error, focus as a separate call\n+ # we can _is_error-check, then type, then restore as a separate\n+ # best-effort call. All four share the persisted lane via session.\n+ if is_absolute:\n+ anchor_result = asyncio.run(_call_execute(\n+ _anchor_path_cmd(\"\"), use_daemon, session=session,\n+ ))\n+ if _is_error(anchor_result):\n+ # Anchor failed — we never moved, so no restore is needed.\n+ return _parse_execute_result(anchor_result, \"focus\")\n+\n+ focus_result = asyncio.run(_call_execute(\n+ f\"focus {_q(translated_path)}\", use_daemon, session=session,\n+ ))\n+ if _is_error(focus_result):\n+ # Focus failed — restore cwd before returning so the lane\n+ # doesn't stay parked at the anchor (only relevant when we\n+ # actually moved, i.e. the absolute path branch).\n+ if is_absolute:\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+ return _parse_execute_result(focus_result, \"focus\")\n+\n+ type_result = asyncio.run(_call_execute(\n+ f\"type {_q(text)}\", use_daemon, session=session,\n+ ))\n+\n+ if is_absolute:\n+ # Best-effort restore — type already succeeded, so a restore\n+ # failure is cosmetic. The next harness cd will correct any\n+ # drift.\n+ asyncio.run(_call_execute(\n+ _restore_cwd_cmd(session), use_daemon, session=session,\n+ ))\n+\n+ return _parse_execute_result(type_result, \"type\")\n \n \n # ── Daemon control functions ───────────────────────────────────────────\n"}],"string":"[\n {\n \"comment\": \"`target_path` can become `None` when `path == \\\\\\\"\\\\\\\"` and `session.working_dir is None`, but `backend.grep` is typed/used as taking strings. This can lead to inconsistent behavior (e.g., bypassing the `cd` logic) and makes downstream quoting/formatting fragile. Normalize to a string, e.g., `target_path = path if path else (session.working_dir or \\\\\\\"/\\\\\\\")`, and keep `prev` consistent with that choice.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/core/fs.py\",\n \"hunk\": \"@@ -113,16 +113,7 @@ def grep_elements(session: \\\"Session\\\", pattern: str, path: str = \\\"\\\") -> dict:\\n \\\"\\\"\\\"\\n target_path = path if path else session.working_dir\\n use_daemon = session.daemon_mode\\n-\\n- # DOMShell's grep searches from the server-side CWD. To root the search\\n- # at the requested path, cd there first, grep, then restore.\\n- if target_path and target_path != \\\"/\\\":\\n- cd_result = backend.cd(target_path, use_daemon=use_daemon)\\n- if hasattr(cd_result, 'isError') and cd_result.isError:\\n- return cd_result\\n-\\n- try:\\n- return backend.grep(pattern, use_daemon=use_daemon)\\n- finally:\\n- if target_path and target_path != \\\"/\\\":\\n- backend.cd(session.working_dir or \\\"/\\\", use_daemon=use_daemon)\\n+ prev = session.working_dir or \\\"/\\\"\\n+ return backend.grep(\\n+ pattern, path=target_path, prev=prev, use_daemon=use_daemon\\n+ )\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/core/fs.py b/browser/agent-harness/cli_anything/browser/core/fs.py\\nindex 303cc50072..eced7b9913 100644\\n--- a/browser/agent-harness/cli_anything/browser/core/fs.py\\n+++ b/browser/agent-harness/cli_anything/browser/core/fs.py\\n@@ -32,7 +32,7 @@ def list_elements(session: \\\"Session\\\", path: str = \\\"\\\") -> dict:\\n \\\"\\\"\\\"\\n target_path = path if path else session.working_dir\\n use_daemon = session.daemon_mode\\n- return backend.ls(target_path, use_daemon=use_daemon)\\n+ return backend.ls(target_path, use_daemon=use_daemon, session=session)\\n \\n \\n def change_directory(session: \\\"Session\\\", path: str) -> dict:\\n@@ -69,7 +69,7 @@ def change_directory(session: \\\"Session\\\", path: str) -> dict:\\n path = session.working_dir.rstrip(\\\"/\\\") + \\\"/\\\" + path\\n \\n use_daemon = session.daemon_mode\\n- result = backend.cd(path, use_daemon=use_daemon)\\n+ result = backend.cd(path, use_daemon=use_daemon, session=session)\\n # Only update working_dir if backend succeeded\\n if isinstance(result, dict) and \\\"error\\\" not in result:\\n new_working_dir = result.get(\\\"path\\\", path)\\n@@ -93,7 +93,7 @@ def read_element(session: \\\"Session\\\", path: str = \\\"\\\") -> dict:\\n \\\"\\\"\\\"\\n target_path = path if path else session.working_dir\\n use_daemon = session.daemon_mode\\n- return backend.cat(target_path, use_daemon=use_daemon)\\n+ return backend.cat(target_path, use_daemon=use_daemon, session=session)\\n \\n \\n def grep_elements(session: \\\"Session\\\", pattern: str, path: str = \\\"\\\") -> dict:\\n@@ -113,16 +113,11 @@ def grep_elements(session: \\\"Session\\\", pattern: str, path: str = \\\"\\\") -> dict:\\n \\\"\\\"\\\"\\n target_path = path if path else session.working_dir\\n use_daemon = session.daemon_mode\\n-\\n- # DOMShell's grep searches from the server-side CWD. To root the search\\n- # at the requested path, cd there first, grep, then restore.\\n- if target_path and target_path != \\\"/\\\":\\n- cd_result = backend.cd(target_path, use_daemon=use_daemon)\\n- if hasattr(cd_result, 'isError') and cd_result.isError:\\n- return cd_result\\n-\\n- try:\\n- return backend.grep(pattern, use_daemon=use_daemon)\\n- finally:\\n- if target_path and target_path != \\\"/\\\":\\n- backend.cd(session.working_dir or \\\"/\\\", use_daemon=use_daemon)\\n+ prev = session.working_dir or \\\"/\\\"\\n+ return backend.grep(\\n+ pattern,\\n+ path=target_path,\\n+ prev=prev,\\n+ use_daemon=use_daemon,\\n+ session=session,\\n+ )\\n\"\n },\n {\n \"comment\": \"The new parameter name `prev` is ambiguous in a public wrapper API (it’s not obvious it means the cwd-to-restore-after-search). Consider renaming it to something more explicit like `restore_cwd`/`restore_path`/`cwd_before` to reduce misuse and improve readability at call sites.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -275,17 +289,28 @@ def cat(path: str, use_daemon: bool = False) -> dict:\\n >>> cat(\\\"/main/button[0]\\\")\\n {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(f\\\"cat {_q(path)}\\\", use_daemon))\\n \\n \\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n+def grep(\\n+ pattern: str,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+) -> dict:\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"Previously, `grep_elements` restored the cwd in a Python `finally:` block, guaranteeing the session/server cwd is restored even if `grep` fails. With the new multi-line command approach, restoring cwd now depends on `domshell_execute` continuing to execute subsequent lines after an error. To avoid leaving the server cwd changed on failure, consider detecting an error result and issuing a best-effort follow-up `cd <prev>` (or reverting to a two-step approach only on error).\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -294,13 +319,14 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\\n Example:\\n >>> grep(\\\"Login\\\")\\n {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\")\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"]}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n- ))\\n- return result\\n+ if path and path != \\\"/\\\":\\n+ command = f\\\"cd {_q(path)}\\\\ngrep {_q(pattern)}\\\\ncd {_q(prev)}\\\"\\n+ else:\\n+ command = f\\\"grep {_q(pattern)}\\\"\\n+ return asyncio.run(_call_execute(command, use_daemon))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"`type_text` uses a newline as a command separator. If `text` itself contains a newline, `_q(text)` will include that newline and can unintentionally split the command into additional lines, changing behavior or causing parse errors. To make this safe, either (a) escape/encode newlines in `text` in a way DOMShell understands, or (b) explicitly reject multi-line `text` with a clear error and provide an alternative method for multi-line input.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -392,23 +414,8 @@ def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n Returns:\\n Dict with action result\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n- )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- return asyncio.run(_focus_and_type())\\n+ command = f\\\"focus {_q(path)}\\\\ntype {_q(text)}\\\"\\n+ return asyncio.run(_call_execute(command, use_daemon))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"The `is_available()` example hard-codes `v2.0.0`, but (based on the snippet shown) this function appears to be a generic availability check rather than an explicit minimum-version gate. Either (1) update `is_available()` to actually validate `>= 2.0.0` if that’s now required, or (2) make the example/version wording generic to avoid implying a version guarantee.\\n\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -78,7 +84,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell v2.0.0 is available\\\")\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"The new behavior builds and sends multi-line command strings (including quoting) via `_call_execute`, but the existing tests only validate higher-level calls into `backend.grep` (and not what command string is produced). Add unit coverage that patches `_call_execute` to assert the exact `command` produced for both cases: rooted search (`cd ...\\\\\\\\ngrep ...\\\\\\\\ncd ...`) and default search (`grep ...`), including at least one case with spaces/special characters to validate quoting.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -294,13 +319,14 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\\n Example:\\n >>> grep(\\\"Login\\\")\\n {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\")\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"]}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n- ))\\n- return result\\n+ if path and path != \\\"/\\\":\\n+ command = f\\\"cd {_q(path)}\\\\ngrep {_q(pattern)}\\\\ncd {_q(prev)}\\\"\\n+ else:\\n+ command = f\\\"grep {_q(pattern)}\\\"\\n+ return asyncio.run(_call_execute(command, use_daemon))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Preserve positional compatibility for grep use_daemon arg**\\n\\nChanging `grep` from `grep(pattern, use_daemon=False)` to `grep(pattern, path=\\\"\\\", prev=\\\"/\\\", use_daemon=False)` breaks existing positional callers: a call like `grep(\\\"Login\\\", True)` now binds `True` to `path` instead of `use_daemon`, producing a `cd True` command sequence and disabling daemon mode. This is a runtime regression for any downstream code using the previously valid positional form, despite the API being described as unchanged.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -275,17 +289,28 @@ def cat(path: str, use_daemon: bool = False) -> dict:\\n >>> cat(\\\"/main/button[0]\\\")\\n {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(f\\\"cat {_q(path)}\\\", use_daemon))\\n \\n \\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n+def grep(\\n+ pattern: str,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Reject newlines before quoting DOMShell arguments**\\n\\nBecause `domshell_execute` splits commands on newlines before shell-style quote parsing (as noted in `_assert_single_line`), `shlex.quote` alone does not protect the single-command wrappers. Inputs like `open_url(\\\"https://example.com\\\\nclick /admin\\\")`, `click(\\\"/safe\\\\nopen https://evil.test\\\")`, or unrooted `grep(\\\"x\\\\nclick /admin\\\")` are quoted with an embedded newline and become multiple DOMShell commands; only `type_text` and rooted `grep` currently reject these characters. Centralizing the newline check in `_q` (or applying it to every wrapper) would close the injection path introduced by switching from structured MCP arguments to command strings.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -110,16 +116,57 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n-) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\\"\\\"\\\"\\n+ return shlex.quote(arg)\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"When `use_daemon=False`, each `asyncio.run(_call_execute(...))` spawns a brand-new MCP server subprocess (see `_call_execute`'s `stdio_client(server_params)` branch). DOMShell's cwd lives in that server process, so the leading `cd {path}` is discarded with the subprocess before the subsequent `grep` runs — the grep ends up rooted at the default cwd, not at `path`, and the trailing `cd {prev}` is a no-op. The rooted-grep contract only holds in daemon mode. Either send all three commands in a single multi-line `domshell_execute` call (which is also the one-round-trip win the docstring already alludes to), or guard the multi-call form behind `use_daemon=True` and raise/fallback otherwise. The existing tests don't catch this because they mock `_call_execute` and never exercise the subprocess-per-call behavior.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -294,13 +386,21 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\\n Example:\\n >>> grep(\\\"Login\\\")\\n {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\")\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"]}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n- ))\\n- return result\\n+ if path and path != \\\"/\\\":\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+ cd_result = asyncio.run(_call_execute(f\\\"cd {_q(path)}\\\", use_daemon))\\n+ if _is_error(cd_result):\\n+ return cd_result\\n+ try:\\n+ return asyncio.run(_call_execute(f\\\"grep {_q(pattern)}\\\", use_daemon))\\n+ finally:\\n+ asyncio.run(_call_execute(f\\\"cd {_q(prev)}\\\", use_daemon))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"The substring heuristic produces false positives for any legitimate result whose first text content starts with \\\"error\\\" (e.g., a `grep \\\"error\\\"` match list, a `cat` of an element labeled \\\"Error message\\\", a page title containing \\\"Error\\\"). Because `_is_error` gates the rooted-`grep` short-circuit, a successful `cd` whose response text happens to start with \\\"error\\\" would cause `grep_elements` to skip the actual grep and return the cd response as if it were a failure. Prefer relying solely on the structured signals (`isError` attribute / `isError` or `error` dict keys) and dropping the text-prefix fallback, or restrict the textual check to a strict format DOMShell actually emits (e.g., `\\\"Error:\\\"` exactly).\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -110,16 +116,76 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n-) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got: {arg!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Best-effort check that a ``domshell_execute`` result represents an error.\\n+\\n+ Inspects ``isError`` if the MCP SDK populated it; otherwise scans the\\n+ concatenated text content for a leading \\\"error\\\". Robust to both the\\n+ raw ``CallToolResult`` object and the dict shapes used in unit tests.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\"):\\n+ return True\\n+ if \\\"error\\\" in result:\\n+ return True\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text.strip().lower().startswith(\\\"error\\\")\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"Dropping the bound exception name means every failure on the daemon path — not just a dead connection — is silently swallowed and retried via a fresh subprocess, with no signal in logs about what went wrong. A transient daemon-side bug or a programming error in the arguments will look like an unrelated MCP failure when the spawn path also fails. Consider keeping `except Exception as e:` and logging it at debug/warning level before falling back, so daemon-only regressions are diagnosable.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -133,9 +199,11 @@ async def _call_tool(\\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", {\\\"command\\\": command}\\n+ )\\n return result\\n- except Exception as e:\\n+ except Exception:\\n # Daemon died, fall back to spawning new server\\n await _stop_daemon()\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"The default for `path` is `\\\"/\\\"` (not `\\\"\\\"`), so the `if path` branch is always taken and the `else \\\"ls\\\"` arm is unreachable for callers using the default. If the intent is to fall back to a bare `ls` on empty input, also test for `path == \\\"\\\"` explicitly (e.g., `if path and path != \\\"\\\"`) — or just always emit `f\\\"ls {_q(path)}\\\"` and drop the dead branch.\\n\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -239,8 +313,8 @@ def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n >>> ls(\\\"/\\\")\\n {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n+ command = f\\\"ls {_q(path)}\\\" if path else \\\"ls\\\"\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Keep rooted grep in one MCP session**\\n\\nIn non-daemon mode, each `_call_execute` opens and initializes a fresh stdio `ClientSession`, and DOMShell 2 isolates state per MCP client/lane; as a result the `cd` here does not carry over to the subsequent `grep` call. Any `fs grep` scoped to a non-root path or current working directory will search from the new session's default cwd instead, while the final restore also runs in yet another session. This needs to use one `domshell_execute` call (or another single-session sequence) for `cd` + `grep` + restore.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -294,13 +386,21 @@ def grep(pattern: str, use_daemon: bool = False) -> dict:\\n Example:\\n >>> grep(\\\"Login\\\")\\n {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\")\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"]}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n- ))\\n- return result\\n+ if path and path != \\\"/\\\":\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+ cd_result = asyncio.run(_call_execute(f\\\"cd {_q(path)}\\\", use_daemon))\\n+ if _is_error(cd_result):\\n+ return cd_result\\n+ try:\\n+ return asyncio.run(_call_execute(f\\\"grep {_q(pattern)}\\\", use_daemon))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Reuse DOMShell lane across non-daemon calls**\\n\\nIn the default `use_daemon=False` path this opens a brand-new MCP `ClientSession` for every wrapper call, but DOMShell 2 assigns each MCP client its own fresh lane/group. That means ordinary REPL workflows without `--daemon`, such as `page open https://example.com` followed by `fs ls` or `act click`, execute the second command in a different fresh lane instead of the tab opened by the first command. Persist the DOMShell `group_id` returned by `domshell_execute` or keep a session per CLI session so non-daemon mode preserves browser state across commands.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -149,7 +193,9 @@ async def _call_tool(\\n async with stdio_client(server_params) as (read, write):\\n async with ClientSession(read, write) as session:\\n await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ result = await session.call_tool(\\n+ \\\"domshell_execute\\\", {\\\"command\\\": command}\\n+ )\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"These imports are placed in the middle of the module (after numerous test definitions) rather than at the top with the other imports. Move `SimpleNamespace` and `Session` up to the existing import block at the top of the file to follow PEP 8 and avoid surprising readers/tools that expect all imports to be grouped at the top.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\",\n \"hunk\": \"@@ -0,0 +1,414 @@\\n+\\\"\\\"\\\"Wire-format tests for cli_anything.browser.utils.domshell_backend.\\n+\\n+These tests patch the async ``_call_execute`` helper and assert the exact\\n+command string sent to the DOMShell ``domshell_execute`` tool, so wire-format\\n+regressions (quoting, command names, multi-line layout, restore ordering)\\n+fail loudly.\\n+\\\"\\\"\\\"\\n+\\n+import pytest\\n+from unittest.mock import AsyncMock, call, patch\\n+\\n+from cli_anything.browser.utils import domshell_backend as backend\\n+\\n+\\n+# ── grep: command string and call sequencing ──────────────────────────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_unrooted_produces_single_grep_call(mock_call):\\n+ \\\"\\\"\\\"Unrooted grep dispatches one ``grep <pattern>`` call.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.grep(\\\"Login\\\")\\n+\\n+ # session=None when no session is passed (default).\\n+ assert mock_call.call_args_list == [call(\\\"grep Login\\\", False, session=None)]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_emits_single_multiline_call(mock_call):\\n+ \\\"\\\"\\\"Rooted grep is ONE multi-line ``cd / grep / cd back`` execute call.\\n+\\n+ Each ``_call_execute`` in non-daemon mode opens a fresh MCP session\\n+ that lands in its own DOMShell 2.x lane, so splitting cd / grep /\\n+ restore across separate calls would lose the cwd between them. The\\n+ three lines must travel in one ``domshell_execute`` call to share\\n+ a lane.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\")\\n+\\n+ assert mock_call.call_args_list == [\\n+ call(\\\"cd /main\\\\ngrep Login\\\\ncd /\\\", False, session=None),\\n+ ]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_uses_single_call_for_lane_isolation(mock_call):\\n+ \\\"\\\"\\\"Documents the lane-isolation contract: ONE call, not three.\\n+\\n+ The trailing ``cd prev`` is delivered as the final line of the same\\n+ multi-line command and runs even if ``grep`` errors, per DOMShell's\\n+ documented continue-on-error semantics\\n+ (`apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\")\\n+\\n+ assert mock_call.call_count == 1\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_quotes_path_with_spaces(mock_call):\\n+ \\\"\\\"\\\"Paths with whitespace are shell-quoted inside the multi-line command.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.grep(\\\"Login\\\", path=\\\"/path with spaces\\\", prev=\\\"/\\\")\\n+\\n+ cmd = mock_call.call_args.args[0]\\n+ # shlex.quote single-quotes anything containing whitespace; the rest\\n+ # of the multi-line layout (grep + cd back) stays intact.\\n+ assert cmd.startswith(\\\"cd '/path with spaces'\\\\n\\\")\\n+ assert \\\"\\\\ngrep Login\\\\n\\\" in cmd\\n+ assert cmd.endswith(\\\"\\\\ncd /\\\")\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_pattern_with_shell_metacharacters_quoted(mock_call):\\n+ \\\"\\\"\\\"Patterns with shell metacharacters get quoted (no injection via grep).\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.grep(\\\"$(rm -rf /)\\\")\\n+\\n+ grep_cmd = mock_call.call_args_list[0].args[0]\\n+ # shlex.quote will single-quote the dangerous payload.\\n+ assert grep_cmd == \\\"grep '$(rm -rf /)'\\\"\\n+\\n+\\n+def test_grep_rejects_positional_path():\\n+ \\\"\\\"\\\"grep(pattern, path) — positional path raises TypeError.\\n+\\n+ Pre-migration callers writing ``grep(\\\"Login\\\", True)`` to mean\\n+ ``use_daemon=True`` must not silently get ``path=True``.\\n+ \\\"\\\"\\\"\\n+ with pytest.raises(TypeError):\\n+ backend.grep(\\\"Login\\\", True) # type: ignore[misc]\\n+\\n+\\n+def test_grep_rejects_positional_use_daemon():\\n+ \\\"\\\"\\\"Even the third positional slot is blocked.\\\"\\\"\\\"\\n+ with pytest.raises(TypeError):\\n+ backend.grep(\\\"Login\\\", \\\"/main\\\", \\\"/\\\", True) # type: ignore[misc]\\n+\\n+\\n+def test_grep_keyword_use_daemon_still_works():\\n+ \\\"\\\"\\\"Keyword call against the new signature still type-checks at call time.\\\"\\\"\\\"\\n+ with patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock) as mock_call:\\n+ mock_call.return_value = {}\\n+ backend.grep(\\\"Login\\\", use_daemon=True)\\n+ assert mock_call.call_args_list == [call(\\\"grep Login\\\", True, session=None)]\\n+\\n+\\n+# ── type_text: focus+type pairing and newline injection guard ─────────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_type_text_emits_focus_then_type_in_one_call(mock_call):\\n+ \\\"\\\"\\\"type_text builds a single multi-line ``focus … \\\\\\\\ntype …`` execute call.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.type_text(\\\"search_input\\\", \\\"machine learning\\\")\\n+\\n+ assert mock_call.call_args_list == [\\n+ call(\\\"focus search_input\\\\ntype 'machine learning'\\\", False, session=None),\\n+ ]\\n+\\n+\\n+def test_type_text_rejects_newline_in_text():\\n+ \\\"\\\"\\\"``\\\\\\\\n`` in text would inject a new DOMShell command — must raise.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.type_text(\\\"search_input\\\", \\\"line1\\\\nline2\\\")\\n+\\n+\\n+def test_type_text_rejects_carriage_return_in_text():\\n+ \\\"\\\"\\\"``\\\\\\\\r`` is just as dangerous as ``\\\\\\\\n`` for DOMShell's line splitter.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.type_text(\\\"search_input\\\", \\\"line1\\\\rline2\\\")\\n+\\n+\\n+def test_type_text_rejects_newline_in_path():\\n+ \\\"\\\"\\\"A newline in the path argument also injects — guard both fields.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.type_text(\\\"input\\\\nclick /admin\\\", \\\"anything\\\")\\n+\\n+\\n+# ── grep: newline guard on rooted multi-step path ─────────────────────\\n+\\n+\\n+def test_grep_rejects_newline_in_path():\\n+ \\\"\\\"\\\"Rooted grep interpolates path into a multi-line cd/grep/cd — reject newlines.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\\nclick /admin\\\", prev=\\\"/\\\")\\n+\\n+\\n+def test_grep_rejects_newline_in_pattern():\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.grep(\\\"Login\\\\nclick /admin\\\", path=\\\"/main\\\", prev=\\\"/\\\")\\n+\\n+\\n+def test_grep_rejects_newline_in_prev():\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\\nclick /admin\\\")\\n+\\n+\\n+# ── Centralized newline guard in _q ──────────────────────────────────\\n+#\\n+# The per-wrapper _assert_single_line calls above cover type_text and\\n+# rooted grep with field-named error messages. The newline check inside\\n+# _q itself catches the same class of injection for every OTHER wrapper\\n+# that flows user input through the quoting layer (open_url, click, cd,\\n+# cat, unrooted grep, etc.) — without needing a per-call guard at each\\n+# site.\\n+\\n+\\n+def test_q_rejects_line_feeds():\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend._q(\\\"foo\\\\nbar\\\")\\n+\\n+\\n+def test_q_rejects_carriage_returns():\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend._q(\\\"foo\\\\rbar\\\")\\n+\\n+\\n+def test_q_accepts_normal_strings():\\n+ \\\"\\\"\\\"Plain strings pass through to shlex.quote unchanged.\\\"\\\"\\\"\\n+ assert backend._q(\\\"simple\\\") == \\\"simple\\\"\\n+ assert backend._q(\\\"hello world\\\") == \\\"'hello world'\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_unrooted_grep_pattern_rejects_newlines(mock_call):\\n+ \\\"\\\"\\\"The unrooted grep path was not field-guarded — _q catches it.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.grep(\\\"evil\\\\nclick /admin\\\")\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_open_url_rejects_newlines(mock_call):\\n+ \\\"\\\"\\\"open_url has no per-call _assert_single_line — _q must catch it.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.open_url(\\\"https://example.com\\\\nclick /admin\\\")\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_click_rejects_newlines(mock_call):\\n+ \\\"\\\"\\\"click is covered structurally by _q without a per-call guard.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.click(\\\"/main/button[0]\\\\nclick /admin\\\")\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_rejects_newlines(mock_call):\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.cd(\\\"/main\\\\nclick /admin\\\")\\n+\\n+\\n+# ── DOMShell lane persistence across _call_execute calls ─────────────\\n+#\\n+# DOMShell 2.x assigns a fresh lane (Chrome tab-group) to every new MCP\\n+# session. In non-daemon mode each _call_execute opens its own stdio\\n+# ClientSession, so without explicit group_id every command would land\\n+# in a brand-new lane and lose browser state from the previous call.\\n+# The fix: parse the trailing \\\"[lane: <id>]\\\" marker DOMShell appends to\\n+# each reply, store it on the harness Session, and pass group_id=<id>\\n+# on every subsequent call.\\n+\\n+\\n+from types import SimpleNamespace\\n+\\n+from cli_anything.browser.core.session import Session\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py b/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\\nnew file mode 100644\\nindex 0000000000..2b75fe0097\\n--- /dev/null\\n+++ b/browser/agent-harness/cli_anything/browser/tests/test_domshell_backend.py\\n@@ -0,0 +1,1337 @@\\n+\\\"\\\"\\\"Wire-format tests for cli_anything.browser.utils.domshell_backend.\\n+\\n+These tests patch the async ``_call_execute`` helper and assert the exact\\n+command string sent to the DOMShell ``domshell_execute`` tool, so wire-format\\n+regressions (quoting, command names, multi-line layout, restore ordering)\\n+fail loudly.\\n+\\\"\\\"\\\"\\n+\\n+from types import SimpleNamespace\\n+from unittest.mock import AsyncMock, call, patch\\n+\\n+import pytest\\n+\\n+from cli_anything.browser.core.session import Session\\n+from cli_anything.browser.utils import domshell_backend as backend\\n+\\n+\\n+# ── Path translation: harness `/` vs DOMShell `~/` ───────────────────\\n+\\n+\\n+def test_translate_path_root_is_absolute_empty():\\n+ \\\"\\\"\\\"`/` → (\\\"\\\", True). Absolute target with no further subdir.\\\"\\\"\\\"\\n+ assert backend._translate_path(\\\"/\\\") == (\\\"\\\", True)\\n+\\n+\\n+def test_translate_path_empty_is_relative_empty():\\n+ \\\"\\\"\\\"`\\\"\\\"` → (\\\"\\\", False). Bare/relative no-op; caller decides what to do.\\\"\\\"\\\"\\n+ assert backend._translate_path(\\\"\\\") == (\\\"\\\", False)\\n+\\n+\\n+def test_translate_path_strips_all_leading_slashes():\\n+ \\\"\\\"\\\"`//main` collapses to `(\\\"main\\\", True)` via lstrip.\\\"\\\"\\\"\\n+ assert backend._translate_path(\\\"/main\\\") == (\\\"main\\\", True)\\n+ assert backend._translate_path(\\\"//main\\\") == (\\\"main\\\", True)\\n+ assert backend._translate_path(\\\"///main\\\") == (\\\"main\\\", True)\\n+\\n+\\n+def test_translate_path_preserves_relative():\\n+ \\\"\\\"\\\"Relative paths pass through unchanged — DOMShell handles them.\\\"\\\"\\\"\\n+ assert backend._translate_path(\\\"main\\\") == (\\\"main\\\", False)\\n+ assert backend._translate_path(\\\"..\\\") == (\\\"..\\\", False)\\n+ assert backend._translate_path(\\\".\\\") == (\\\".\\\", False)\\n+\\n+\\n+# ── ls / cd / cat / click: absolute paths anchor at %here% ───────────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_absolute_path_uses_three_separate_calls(mock_call):\\n+ \\\"\\\"\\\"Split-and-check: anchor → bare ls → restore, three distinct calls.\\n+\\n+ Anchor success is load-bearing — if the cd fails, ls would run in\\n+ the wrong cwd. Tested separately by\\n+ test_ls_anchor_failure_short_circuits.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ sess = _make_session(working_dir=\\\"/main\\\")\\n+ backend.ls(\\\"/main\\\", session=sess)\\n+ assert mock_call.call_count == 3\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%/main\\\" # anchor\\n+ assert mock_call.call_args_list[1].args[0] == \\\"ls\\\" # op\\n+ assert mock_call.call_args_list[2].args[0] == \\\"cd %here%/main\\\" # restore\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_root_from_drifted_cwd_anchors_at_here(mock_call):\\n+ \\\"\\\"\\\"The Codex P1 case: `ls /` from a drifted `/main` cwd.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ sess = _make_session(working_dir=\\\"/main\\\")\\n+ backend.ls(\\\"/\\\", session=sess)\\n+ assert mock_call.call_count == 3\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\" # anchor at tab root\\n+ assert mock_call.call_args_list[1].args[0] == \\\"ls\\\" # bare ls\\n+ assert mock_call.call_args_list[2].args[0] == \\\"cd %here%/main\\\" # back to /main\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_relative_path_no_wrap(mock_call):\\n+ \\\"\\\"\\\"Relative `ls main` runs against lane cwd — no anchor, no restore.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.ls(\\\"main\\\")\\n+ assert mock_call.call_args.args[0] == \\\"ls main\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_absolute_path_with_spaces_quoted(mock_call):\\n+ \\\"\\\"\\\"The `%here%/<deeper>` token is shell-quoted as one unit.\\n+\\n+ Upstream-smoked: `cd '%here%/<path>'` works in DOMShell 2.0.x — so\\n+ whitespace and other shell metachars in absolute targets are safe.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.ls(\\\"/path with spaces\\\", session=_make_session(working_dir=\\\"/\\\"))\\n+ # Anchor (first call) is the quoted form.\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd '%here%/path with spaces'\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_root_uses_here(mock_call):\\n+ \\\"\\\"\\\"`cd /` → `cd %here%`. Single line — cd's purpose IS the new state.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.cd(\\\"/\\\")\\n+ assert mock_call.call_args.args[0] == \\\"cd %here%\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_absolute_is_single_line_no_restore(mock_call):\\n+ \\\"\\\"\\\"`cd /main` → `cd %here%/main`. One line, no restore.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.cd(\\\"/main\\\")\\n+ assert mock_call.call_args.args[0] == \\\"cd %here%/main\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_subpath_with_indexing(mock_call):\\n+ \\\"\\\"\\\"Brackets are shell-metachars — `_here_path` quotes the full token.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.cd(\\\"/main/div[0]\\\")\\n+ assert mock_call.call_args.args[0] == \\\"cd '%here%/main/div[0]'\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_relative_quoted(mock_call):\\n+ \\\"\\\"\\\"Relative `cd main` is quoted via _q (handles spaces / metachars).\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.cd(\\\"main\\\")\\n+ assert mock_call.call_args.args[0] == \\\"cd main\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cat_absolute_path_uses_three_separate_calls(mock_call):\\n+ \\\"\\\"\\\"`cat /main/btn`: anchor at tab root → cat main/btn → restore.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ backend.cat(\\\"/main/btn\\\", session=sess)\\n+ assert mock_call.call_count == 3\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\"\\n+ assert mock_call.call_args_list[1].args[0] == \\\"cat main/btn\\\"\\n+ assert mock_call.call_args_list[2].args[0] == \\\"cd %here%\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cat_relative_no_wrap(mock_call):\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.cat(\\\"main/btn\\\")\\n+ assert mock_call.call_args.args[0] == \\\"cat main/btn\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cat_root_path_does_not_raise_and_returns_parseable_result(mock_call):\\n+ \\\"\\\"\\\"backend.cat(\\\"/\\\") and backend.cat(\\\"\\\") at the absolute root should\\n+ NOT raise a Python ValueError. Pre-migration behavior was to send\\n+ ``cat ''`` to DOMShell and surface its ``Usage: cat <name>`` error\\n+ string; the round-5 Python-side guard converted the kernel error\\n+ into a ValueError, which broke ``fs.read_element(session, \\\"\\\")``\\n+ callers landed at ``/``. @yuh-yang R3 blocker 1 required restoring\\n+ pre-migration behavior — guard removed, both inputs now reach\\n+ DOMShell, which has the same ``if (!targetName)`` check and\\n+ returns its standard Usage error.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\n+ \\\"\\\\x1b[31mUsage: cat <name> (see cat --help)\\\\x1b[0m\\\\n[lane: shared]\\\"\\n+ )\\n+ sess = _make_session(working_dir=\\\"/\\\") # satisfies absolute branch's session check\\n+\\n+ # MUST NOT raise — that was the regression.\\n+ result_root = backend.cat(\\\"/\\\", session=sess)\\n+ result_empty = backend.cat(\\\"\\\")\\n+\\n+ # Both surface DOMShell's error as a parsed dict, not a Python exception.\\n+ for r in (result_root, result_empty):\\n+ assert isinstance(r, dict)\\n+ # _parse_execute_result detects ANSI red → routes through error path.\\n+ assert \\\"error\\\" in r\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_click_absolute_path_uses_three_separate_calls(mock_call):\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ sess = _make_session(working_dir=\\\"/main\\\")\\n+ backend.click(\\\"/main/button[0]\\\", session=sess)\\n+ assert mock_call.call_count == 3\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\"\\n+ assert mock_call.call_args_list[1].args[0] == \\\"click 'main/button[0]'\\\"\\n+ assert mock_call.call_args_list[2].args[0] == \\\"cd %here%/main\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_click_relative_no_wrap(mock_call):\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.click(\\\"button[0]\\\")\\n+ assert mock_call.call_args.args[0] == \\\"click 'button[0]'\\\"\\n+\\n+\\n+def test_click_root_raises_value_error():\\n+ with pytest.raises(ValueError, match=\\\"element name is required\\\"):\\n+ backend.click(\\\"/\\\")\\n+ with pytest.raises(ValueError, match=\\\"element name is required\\\"):\\n+ backend.click(\\\"\\\")\\n+\\n+\\n+# ── grep absolute-path anchoring ─────────────────────────────────────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_absolute_uses_three_separate_calls(mock_call):\\n+ \\\"\\\"\\\"Rooted grep (absolute): anchor → grep → restore, three distinct calls.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.grep(\\n+ \\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\", session=_make_session(working_dir=\\\"/\\\"),\\n+ )\\n+ assert mock_call.call_count == 3\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%/main\\\"\\n+ assert mock_call.call_args_list[1].args[0] == \\\"grep -r Login\\\"\\n+ assert mock_call.call_args_list[2].args[0] == \\\"cd %here%\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_absolute_restores_to_session_wd(mock_call):\\n+ \\\"\\\"\\\"Restore (third call) follows session.working_dir, not the `prev`\\n+ kwarg, when the path is absolute — the lane cwd needs to end up\\n+ where the harness thinks it is.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.grep(\\n+ \\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\", session=_make_session(working_dir=\\\"/main\\\"),\\n+ )\\n+ assert mock_call.call_args_list[2].args[0] == \\\"cd %here%/main\\\"\\n+\\n+\\n+# ── Anchor-failure short-circuit (the Codex P2 case per-wrapper) ─────\\n+#\\n+# If the anchor `cd` fails, the operation must NOT run — it would\\n+# resolve against the wrong cwd and produce wrong-target results. Each\\n+# wrapper that uses split-and-check mirrors `type_text`'s\\n+# anchor-failure pattern.\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_anchor_failure_short_circuits(mock_call):\\n+ \\\"\\\"\\\"ls absolute-path anchor failure → only the anchor call ran.\\n+\\n+ Uses DOMShell's actual error shape: ANSI-red-wrapped, command-\\n+ prefixed (\\\"cd: ...\\\") — not the imaginary \\\"Error: ...\\\" prefix that\\n+ silently bypassed ``_is_error`` for several rounds.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\n+ \\\"\\\\x1b[31mcd: tab 12345 is outside the session group\\\\x1b[0m\\\"\\n+ )\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ result = backend.ls(\\\"/main\\\", session=sess)\\n+ assert mock_call.call_count == 1\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%/main\\\"\\n+ assert \\\"error\\\" in result\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cat_anchor_failure_short_circuits(mock_call):\\n+ mock_call.return_value = _make_result(\\n+ \\\"\\\\x1b[31mcd: chrome:// not debuggable\\\\x1b[0m\\\"\\n+ )\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ result = backend.cat(\\\"/main/btn\\\", session=sess)\\n+ assert mock_call.call_count == 1\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\"\\n+ assert \\\"error\\\" in result\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_click_anchor_failure_short_circuits(mock_call):\\n+ \\\"\\\"\\\"Critical for click: a misdirected click could trigger an\\n+ unintended action. Anchor must halt before the click runs.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\n+ \\\"\\\\x1b[31mcd: chrome:// not debuggable\\\\x1b[0m\\\"\\n+ )\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ result = backend.click(\\\"/main/button[0]\\\", session=sess)\\n+ assert mock_call.call_count == 1\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\"\\n+ assert \\\"error\\\" in result\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_anchor_failure_short_circuits(mock_call):\\n+ \\\"\\\"\\\"Rooted grep with anchor failure → grep doesn't run (wrong-scope\\n+ matches would be misleading). Restore also skipped because we\\n+ never moved off the original cwd.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\n+ \\\"\\\\x1b[31mcd: /missing: No such directory\\\\x1b[0m\\\"\\n+ )\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ result = backend.grep(\\\"Login\\\", path=\\\"/missing\\\", prev=\\\"/\\\", session=sess)\\n+ assert mock_call.call_count == 1\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%/missing\\\"\\n+ assert \\\"error\\\" in result\\n+\\n+\\n+# ── Absolute split-and-check requires session in non-daemon mode ─────\\n+#\\n+# Without a session (and without daemon mode), each `_call_execute` lands\\n+# in a fresh DOMShell lane — the anchor cd's cwd doesn't carry over to\\n+# the operation, producing wrong-scope output. Raise up front to surface\\n+# the misuse instead of silently producing wrong results. (Mirrors\\n+# `type_text`'s round-6.1 guard; propagated to ls/cat/click/grep in\\n+# round 7.2 per Codex P2 #2.)\\n+\\n+\\n+def test_ls_absolute_without_session_raises_in_non_daemon():\\n+ with pytest.raises(ValueError, match=\\\"session\\\"):\\n+ backend.ls(\\\"/main\\\", session=None)\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_absolute_with_daemon_no_session_works(mock_call):\\n+ \\\"\\\"\\\"Daemon mode shares lane via the persistent connection — no\\n+ session required.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.ls(\\\"/main\\\", use_daemon=True, session=None)\\n+ # 3-call split-and-check still happens.\\n+ assert mock_call.call_count == 3\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_relative_without_session_works(mock_call):\\n+ \\\"\\\"\\\"Relative path runs as a single call — no anchor, no lane drift\\n+ risk, so session=None is fine in non-daemon mode.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.ls(\\\"main\\\", session=None)\\n+ assert mock_call.call_count == 1\\n+\\n+\\n+def test_cat_absolute_without_session_raises_in_non_daemon():\\n+ with pytest.raises(ValueError, match=\\\"session\\\"):\\n+ backend.cat(\\\"/main/btn\\\", session=None)\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cat_relative_without_session_works(mock_call):\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.cat(\\\"main/btn\\\", session=None)\\n+ assert mock_call.call_count == 1\\n+\\n+\\n+def test_click_absolute_without_session_raises_in_non_daemon():\\n+ with pytest.raises(ValueError, match=\\\"session\\\"):\\n+ backend.click(\\\"/main/button[0]\\\", session=None)\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_click_relative_without_session_works(mock_call):\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.click(\\\"button[0]\\\", session=None)\\n+ assert mock_call.call_count == 1\\n+\\n+\\n+def test_grep_rooted_absolute_without_session_raises_in_non_daemon():\\n+ \\\"\\\"\\\"Rooted grep with absolute path requires session for lane consistency.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"session\\\"):\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\", session=None)\\n+\\n+\\n+def test_grep_rooted_relative_without_session_raises_in_non_daemon():\\n+ \\\"\\\"\\\"Rooted grep with RELATIVE path also requires session — both\\n+ branches issue 3 separate calls and depend on shared lane state.\\n+ \\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"session\\\"):\\n+ backend.grep(\\\"Login\\\", path=\\\"dialog\\\", prev=\\\"/main\\\", session=None)\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_relative_with_daemon_no_session_works(mock_call):\\n+ \\\"\\\"\\\"Daemon mode shares lane via the persistent connection — no\\n+ session required even for relative-rooted grep.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.grep(\\\"Login\\\", path=\\\"dialog\\\", prev=\\\"/main\\\", use_daemon=True, session=None)\\n+ # 3-call split-and-check still happens.\\n+ assert mock_call.call_count == 3\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_unrooted_without_session_works(mock_call):\\n+ \\\"\\\"\\\"Unrooted grep is a single call — no session required.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.grep(\\\"Login\\\", session=None)\\n+ assert mock_call.call_count == 1\\n+\\n+\\n+# ── _parse_execute_result: dict shapes per command ───────────────────\\n+#\\n+# DOMShell 2.x returns text content; the CLI was written for the\\n+# pre-2.0 per-command tools that returned dicts. These tests lock in\\n+# the translator's per-command shape contract so the CLI doesn't break\\n+# on `result.get(...)` calls.\\n+\\n+\\n+def test_parse_execute_result_ls_extracts_entries():\\n+ result = _make_result(\\\"button[0]\\\\nlink[1]\\\\nimg[2]\\\\n[lane: 7]\\\")\\n+ parsed = backend._parse_execute_result(result, \\\"ls\\\")\\n+ assert parsed[\\\"entries\\\"] == [\\n+ {\\\"name\\\": \\\"button[0]\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"button[0]\\\"},\\n+ {\\\"name\\\": \\\"link[1]\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"link[1]\\\"},\\n+ {\\\"name\\\": \\\"img[2]\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"img[2]\\\"},\\n+ ]\\n+ # Lane marker is stripped from the raw text.\\n+ assert \\\"[lane:\\\" not in parsed[\\\"raw\\\"]\\n+\\n+\\n+def test_parse_execute_result_ls_empty_text_returns_empty_entries():\\n+ parsed = backend._parse_execute_result(_make_result(\\\"[lane: 7]\\\"), \\\"ls\\\")\\n+ assert parsed == {\\\"entries\\\": [], \\\"raw\\\": \\\"\\\"}\\n+\\n+\\n+def test_parse_execute_result_grep_extracts_matches():\\n+ result = _make_result(\\n+ \\\"/main/button[0]\\\\n/main/link[1]\\\\n[lane: 7]\\\"\\n+ )\\n+ parsed = backend._parse_execute_result(result, \\\"grep\\\")\\n+ assert parsed[\\\"matches\\\"] == [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]\\n+ assert \\\"[lane:\\\" not in parsed[\\\"raw\\\"]\\n+\\n+\\n+def test_parse_execute_result_error_returns_error_dict():\\n+ \\\"\\\"\\\"Errors get `error` AND `output` keys — the CLI checks `\\\"error\\\" in\\n+ result` for cd-style guards but also pretty-prints `output`.\\n+\\n+ Uses the actual DOMShell error shape: ANSI-red-wrapped, command-\\n+ prefixed (``ls: ...``).\\n+ \\\"\\\"\\\"\\n+ result = _make_result(\\n+ \\\"\\\\x1b[31mls: main: No such directory\\\\x1b[0m\\\\n[lane: 7]\\\"\\n+ )\\n+ parsed = backend._parse_execute_result(result, \\\"ls\\\")\\n+ assert \\\"error\\\" in parsed\\n+ assert parsed[\\\"error\\\"].startswith(\\\"\\\\x1b[31mls:\\\")\\n+ assert parsed[\\\"output\\\"] == parsed[\\\"error\\\"]\\n+\\n+\\n+def test_parse_execute_result_default_for_non_nav_commands():\\n+ \\\"\\\"\\\"cat/click/focus/type/refresh fall through to the generic\\n+ ``{\\\"output\\\": text}`` shape (nav commands get their own branch —\\n+ see test_parse_execute_result_nav_*).\\\"\\\"\\\"\\n+ for cmd in (\\\"cat\\\", \\\"click\\\", \\\"focus\\\", \\\"type\\\", \\\"refresh\\\"):\\n+ parsed = backend._parse_execute_result(\\n+ _make_result(\\\"done\\\\n[lane: 1]\\\"), cmd,\\n+ )\\n+ assert parsed == {\\\"output\\\": \\\"done\\\"}\\n+\\n+\\n+# ── Nav commands (back/forward/navigate/open): URL/title extraction ──\\n+\\n+\\n+def test_parse_execute_result_nav_extracts_url_and_title():\\n+ \\\"\\\"\\\"back/forward/navigate/open extract `url` and `title` so\\n+ page.go_back/go_forward's `\\\"url\\\" in result` guards fire and\\n+ session.set_url updates correctly. (Codex P2 #1.)\\n+ \\\"\\\"\\\"\\n+ fixture = _make_result(\\n+ \\\"✓ Navigated back\\\\n\\\"\\n+ \\\"URL: https://example.com/page\\\\n\\\"\\n+ \\\"Title: Example Page\\\\n\\\"\\n+ \\\"[lane: 7]\\\"\\n+ )\\n+ for cmd in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ parsed = backend._parse_execute_result(fixture, cmd)\\n+ assert parsed[\\\"url\\\"] == \\\"https://example.com/page\\\"\\n+ assert parsed[\\\"title\\\"] == \\\"Example Page\\\"\\n+ # The raw output is preserved alongside.\\n+ assert \\\"✓ Navigated back\\\" in parsed[\\\"output\\\"]\\n+\\n+\\n+def test_parse_execute_result_nav_omits_url_when_missing():\\n+ \\\"\\\"\\\"Malformed/early response without URL line → `output` only, no crash.\\\"\\\"\\\"\\n+ parsed = backend._parse_execute_result(_make_result(\\\"✓ done\\\\n[lane: 1]\\\"), \\\"back\\\")\\n+ assert parsed == {\\\"output\\\": \\\"✓ done\\\"}\\n+ assert \\\"url\\\" not in parsed\\n+ assert \\\"title\\\" not in parsed\\n+\\n+\\n+def test_parse_execute_result_nav_extracts_url_without_title():\\n+ \\\"\\\"\\\"A response with URL but no Title line still extracts the URL.\\\"\\\"\\\"\\n+ parsed = backend._parse_execute_result(\\n+ _make_result(\\\"URL: https://example.com/x\\\\n[lane: 1]\\\"), \\\"open\\\",\\n+ )\\n+ assert parsed[\\\"url\\\"] == \\\"https://example.com/x\\\"\\n+ assert \\\"title\\\" not in parsed\\n+\\n+\\n+def test_parse_execute_result_nav_title_handles_trailing_whitespace():\\n+ \\\"\\\"\\\"Title regex strips trailing newline/whitespace.\\\"\\\"\\\"\\n+ parsed = backend._parse_execute_result(\\n+ _make_result(\\n+ \\\"URL: https://example.com\\\\n\\\"\\n+ \\\"Title: Spaced Title \\\\n\\\"\\n+ \\\"[lane: 1]\\\"\\n+ ),\\n+ \\\"open\\\",\\n+ )\\n+ assert parsed[\\\"title\\\"] == \\\"Spaced Title\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_back_returns_dict_with_url_key(mock_call):\\n+ \\\"\\\"\\\"End-to-end: backend.back() returns a dict with `url` so\\n+ page.go_back's guard fires. (The Codex P2 #1 regression case.)\\n+ \\\"\\\"\\\"\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ mock_call.return_value = _make_result(\\n+ \\\"✓ Navigated back\\\\n\\\"\\n+ \\\"URL: https://previous.com\\\\n\\\"\\n+ \\\"Title: Previous\\\\n\\\"\\n+ \\\"[lane: 1]\\\"\\n+ )\\n+ result = backend.back(session=sess)\\n+ assert \\\"url\\\" in result\\n+ assert result[\\\"url\\\"] == \\\"https://previous.com\\\"\\n+ assert result[\\\"title\\\"] == \\\"Previous\\\"\\n+\\n+\\n+# ── End-to-end: wrappers return parsed dicts (not CallToolResult) ────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_ls_returns_entries_dict(mock_call):\\n+ \\\"\\\"\\\"`backend.ls(...)` must return ``{\\\"entries\\\": [...]}`` so the CLI\\n+ doesn't AttributeError on `result.get(\\\"entries\\\", [])`. This is the\\n+ Codex P1 shipped regression.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"button[0]\\\\n[lane: 1]\\\")\\n+ result = backend.ls(\\\"main\\\")\\n+ assert \\\"entries\\\" in result\\n+ assert isinstance(result[\\\"entries\\\"], list)\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_returns_matches_dict(mock_call):\\n+ mock_call.return_value = _make_result(\\\"/main/btn[0]\\\\n[lane: 1]\\\")\\n+ result = backend.grep(\\\"Login\\\")\\n+ assert \\\"matches\\\" in result\\n+ assert result[\\\"matches\\\"] == [\\\"/main/btn[0]\\\"]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_returns_dict_with_output(mock_call):\\n+ \\\"\\\"\\\"`backend.cd(...)` returns a dict so `isinstance(result, dict)`\\n+ in fs.change_directory works and `result.get(\\\"path\\\", path)` falls\\n+ back cleanly.\\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"✓ Entered main\\\\n[lane: 1]\\\")\\n+ result = backend.cd(\\\"/main\\\")\\n+ assert isinstance(result, dict)\\n+ assert \\\"error\\\" not in result\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_error_returns_error_dict(mock_call):\\n+ \\\"\\\"\\\"`fs.change_directory` checks `\\\"error\\\" not in result` — make sure\\n+ error paths surface the error key so the harness's working-dir\\n+ update is correctly skipped. Uses the actual DOMShell error shape.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\n+ \\\"\\\\x1b[31mcd: /missing: No such directory\\\\x1b[0m\\\"\\n+ )\\n+ result = backend.cd(\\\"/missing\\\")\\n+ assert \\\"error\\\" in result\\n+\\n+\\n+# ── _is_error helper ─────────────────────────────────────────────────\\n+\\n+\\n+def test_is_error_detects_isError_attribute():\\n+ assert backend._is_error(SimpleNamespace(isError=True)) is True\\n+ assert backend._is_error(SimpleNamespace(isError=False)) is False\\n+\\n+\\n+def test_is_error_detects_dict_keys():\\n+ assert backend._is_error({\\\"isError\\\": True}) is True\\n+ assert backend._is_error({\\\"error\\\": \\\"boom\\\"}) is True\\n+ assert backend._is_error({\\\"path\\\": \\\"/main\\\"}) is False\\n+\\n+\\n+def test_is_error_detects_ansi_red_wrapper():\\n+ \\\"\\\"\\\"Common DOMShell error shape: ANSI red around a command-prefixed\\n+ message. These do NOT start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then ``startswith(\\\"error\\\")``\\n+ failed every one of these, silently regressing the safety chain\\n+ across every wrapper. Catch on the ``\\\\\\\\x1b[31m`` red marker\\n+ instead.\\n+ \\\"\\\"\\\"\\n+ assert backend._is_error(\\n+ _make_result(\\\"\\\\x1b[31mcd: foo: No such directory\\\\x1b[0m\\\")\\n+ ) is True\\n+ assert backend._is_error(\\n+ _make_result(\\\"\\\\x1b[31mfocus: No such element\\\\x1b[0m\\\")\\n+ ) is True\\n+ assert backend._is_error(\\n+ _make_result(\\\"\\\\x1b[31mls: main: No such directory\\\\x1b[0m\\\")\\n+ ) is True\\n+ assert backend._is_error(\\n+ _make_result(\\\"\\\\x1b[31mcd: tab 12345 is outside the session group\\\\x1b[0m\\\")\\n+ ) is True\\n+\\n+\\n+def test_is_error_detects_explicit_error_prefix_without_ansi():\\n+ \\\"\\\"\\\"Fallback: rarer non-coloured errors or pre-stripped input still\\n+ detected via ``\\\"error:\\\"`` prefix.\\n+ \\\"\\\"\\\"\\n+ assert backend._is_error(_make_result(\\\"Error: bad command\\\")) is True\\n+ assert backend._is_error(_make_result(\\\"ERROR: case insensitive\\\")) is True\\n+\\n+\\n+def test_is_error_does_not_flag_success_in_other_colors():\\n+ \\\"\\\"\\\"Anti-false-positive: only ``\\\\\\\\x1b[31m`` (red) signals an error.\\n+ Success commonly wraps in ``\\\\\\\\x1b[32m`` (green) — must not flag.\\n+ \\\"\\\"\\\"\\n+ assert backend._is_error(\\n+ _make_result(\\\"\\\\x1b[32m✓ ok\\\\x1b[0m\\\")\\n+ ) is False\\n+ assert backend._is_error(\\n+ _make_result(\\\"✓ command completed\\\")\\n+ ) is False\\n+ assert backend._is_error(\\n+ _make_result(\\\"✓ Focused\\\\n[lane: 1]\\\")\\n+ ) is False\\n+\\n+\\n+def test_is_error_handles_empty():\\n+ assert backend._is_error(_make_result(\\\"\\\")) is False\\n+\\n+\\n+def test_is_error_handles_missing_content():\\n+ assert backend._is_error(SimpleNamespace()) is False\\n+\\n+\\n+# ── grep: command string and call sequencing ──────────────────────────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_unrooted_produces_single_grep_call(mock_call):\\n+ \\\"\\\"\\\"Unrooted grep dispatches one ``grep -r <pattern>`` call.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.grep(\\\"Login\\\")\\n+\\n+ # session=None when no session is passed (default).\\n+ assert mock_call.call_args_list == [call(\\\"grep -r Login\\\", False, session=None)]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_unrooted_uses_recursive_flag(mock_call):\\n+ \\\"\\\"\\\"Regression: pre-migration ``domshell_grep`` defaulted to\\n+ recursive=True; the unrooted branch must preserve that by passing\\n+ ``-r`` so nested matches aren't silently missed.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.grep(\\\"Login\\\")\\n+ assert mock_call.call_args.args[0] == \\\"grep -r Login\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_uses_recursive_flag(mock_call):\\n+ \\\"\\\"\\\"Regression: the rooted branch's middle call (the grep itself)\\n+ must also pass ``-r``. The 3-call sequence is cd / grep -r / cd-back.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.grep(\\\"Login\\\", path=\\\"main\\\", session=_make_session())\\n+ # grep is the middle of the 3-call sequence.\\n+ assert mock_call.call_args_list[1].args[0] == \\\"grep -r Login\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_emits_three_call_sequence(mock_call):\\n+ \\\"\\\"\\\"Rooted grep is THREE separate ``_call_execute`` calls: anchor →\\n+ grep → restore. Anchor success is load-bearing (would search the\\n+ wrong subtree on cwd drift), so we can't fold this into a single\\n+ multi-line continue-on-error call.\\n+\\n+ Lane sharing across the three calls is preserved via\\n+ ``session.domshell_lane_id`` — see round-4 lane-persistence tests.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\", session=sess)\\n+\\n+ assert mock_call.call_args_list == [\\n+ call(\\\"cd %here%/main\\\", False, session=sess),\\n+ call(\\\"grep -r Login\\\", False, session=sess),\\n+ call(\\\"cd %here%\\\", False, session=sess),\\n+ ]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_rooted_quotes_path_with_spaces(mock_call):\\n+ \\\"\\\"\\\"Absolute paths with whitespace are quoted as `cd '%here%/path with spaces'`.\\n+\\n+ Upstream-smoked: DOMShell's `cd` accepts the quoted form cleanly.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+\\n+ backend.grep(\\\"Login\\\", path=\\\"/path with spaces\\\", prev=\\\"/\\\", session=sess)\\n+\\n+ # Three-call sequence — quoting applies to the anchor (first call).\\n+ assert mock_call.call_args_list == [\\n+ call(\\\"cd '%here%/path with spaces'\\\", False, session=sess),\\n+ call(\\\"grep -r Login\\\", False, session=sess),\\n+ call(\\\"cd %here%\\\", False, session=sess),\\n+ ]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_grep_pattern_with_shell_metacharacters_quoted(mock_call):\\n+ \\\"\\\"\\\"Patterns with shell metacharacters get quoted (no injection via grep).\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+\\n+ backend.grep(\\\"$(rm -rf /)\\\")\\n+\\n+ grep_cmd = mock_call.call_args_list[0].args[0]\\n+ # shlex.quote will single-quote the dangerous payload.\\n+ assert grep_cmd == \\\"grep -r '$(rm -rf /)'\\\"\\n+\\n+\\n+def test_grep_rejects_positional_path():\\n+ \\\"\\\"\\\"grep(pattern, path) — positional path raises TypeError.\\n+\\n+ Pre-migration callers writing ``grep(\\\"Login\\\", True)`` to mean\\n+ ``use_daemon=True`` must not silently get ``path=True``.\\n+ \\\"\\\"\\\"\\n+ with pytest.raises(TypeError):\\n+ backend.grep(\\\"Login\\\", True) # type: ignore[misc]\\n+\\n+\\n+def test_grep_rejects_positional_use_daemon():\\n+ \\\"\\\"\\\"Even the third positional slot is blocked.\\\"\\\"\\\"\\n+ with pytest.raises(TypeError):\\n+ backend.grep(\\\"Login\\\", \\\"/main\\\", \\\"/\\\", True) # type: ignore[misc]\\n+\\n+\\n+def test_grep_keyword_use_daemon_still_works():\\n+ \\\"\\\"\\\"Keyword call against the new signature still type-checks at call time.\\\"\\\"\\\"\\n+ with patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock) as mock_call:\\n+ mock_call.return_value = {}\\n+ backend.grep(\\\"Login\\\", use_daemon=True)\\n+ assert mock_call.call_args_list == [call(\\\"grep -r Login\\\", True, session=None)]\\n+\\n+\\n+# ── type_text: focus+type pairing and newline injection guard ─────────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_type_text_emits_focus_then_type_with_session(mock_call):\\n+ \\\"\\\"\\\"type_text issues focus + type as two separate execute calls.\\n+\\n+ The split is for safety: DOMShell's multi-line splitter continues\\n+ past per-line errors, so a single ``focus path\\\\\\\\ntype text`` call\\n+ would dispatch keys into stale focus if ``focus`` failed. Two calls\\n+ with an error check between them prevents that.\\n+ \\\"\\\"\\\"\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ mock_call.return_value = _make_result(\\\"✓ Focused\\\\n[lane: 1]\\\")\\n+\\n+ backend.type_text(\\\"search_input\\\", \\\"machine learning\\\", session=sess)\\n+\\n+ assert mock_call.call_count == 2\\n+ # Relative path → no anchor wrap.\\n+ assert mock_call.call_args_list[0].args[0] == \\\"focus search_input\\\"\\n+ assert mock_call.call_args_list[1].args[0] == \\\"type 'machine learning'\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_type_text_absolute_path_uses_four_separate_calls(mock_call):\\n+ \\\"\\\"\\\"Absolute focus path: anchor → focus → type → restore, all distinct.\\n+\\n+ type_text is a safety chain, NOT a cleanup-line idiom: it must HALT\\n+ on focus failure rather than continue past it. Wrapping focus in a\\n+ multi-line ``cd %here%\\\\\\\\nfocus\\\\\\\\ncd <restore>`` would re-introduce\\n+ the continue-on-error trap (the anchor's leading \\\"✓\\\" masks the\\n+ focus error in the combined response). Split into four separate\\n+ _call_execute calls, all sharing the persisted lane via session.\\n+ \\\"\\\"\\\"\\n+ sess = _make_session(working_dir=\\\"/main\\\")\\n+ mock_call.return_value = _make_result(\\\"✓\\\\n[lane: 1]\\\")\\n+\\n+ backend.type_text(\\\"/main/input\\\", \\\"hello\\\", session=sess)\\n+\\n+ assert mock_call.call_count == 4\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\"\\n+ assert mock_call.call_args_list[1].args[0] == \\\"focus main/input\\\"\\n+ assert mock_call.call_args_list[2].args[0] == \\\"type hello\\\"\\n+ assert mock_call.call_args_list[3].args[0] == \\\"cd %here%/main\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_type_text_absolute_path_focus_failure_skips_type_and_restores(mock_call):\\n+ \\\"\\\"\\\"The Codex P2 safety case: a stale absolute focus path must halt\\n+ before type can dispatch keys into whatever was previously focused.\\n+ The restore still runs so the lane cwd ends up where the harness\\n+ expects.\\n+ \\\"\\\"\\\"\\n+ sess = _make_session(working_dir=\\\"/main\\\")\\n+ mock_call.side_effect = [\\n+ _make_result(\\\"✓ Entered tab 123\\\\n[lane: 1]\\\"), # cd anchor ok\\n+ _make_result(\\\"\\\\x1b[31mfocus: No such element\\\\x1b[0m\\\"), # focus fails\\n+ _make_result(\\\"✓ Typed\\\\n[lane: 1]\\\"), # MUST NOT be reached\\n+ _make_result(\\\"✓\\\\n[lane: 1]\\\"), # restore\\n+ ]\\n+\\n+ backend.type_text(\\\"/main/missing\\\", \\\"secret_password\\\", session=sess)\\n+\\n+ # Three calls: anchor, focus, restore. Type is skipped because the\\n+ # focus error halts the safety chain before keys are dispatched.\\n+ assert mock_call.call_count == 3\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\"\\n+ assert mock_call.call_args_list[1].args[0] == \\\"focus main/missing\\\"\\n+ assert mock_call.call_args_list[2].args[0] == \\\"cd %here%/main\\\"\\n+ # Critically — the \\\"type secret_password\\\" command was never sent.\\n+ for call_args in mock_call.call_args_list:\\n+ assert \\\"type\\\" not in call_args.args[0].split(\\\"\\\\n\\\")[0]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_type_text_anchor_failure_does_not_attempt_focus(mock_call):\\n+ \\\"\\\"\\\"If even the anchor cd fails (e.g. chrome:// not debuggable),\\n+ neither focus nor type runs. No restore needed because we never\\n+ moved off the original cwd.\\n+ \\\"\\\"\\\"\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ mock_call.return_value = _make_result(\\n+ \\\"\\\\x1b[31mcd: chrome:// not debuggable\\\\x1b[0m\\\"\\n+ )\\n+\\n+ backend.type_text(\\\"/some/path\\\", \\\"text\\\", session=sess)\\n+\\n+ assert mock_call.call_count == 1\\n+ assert mock_call.call_args_list[0].args[0] == \\\"cd %here%\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_type_text_relative_path_focus_failure_skips_type(mock_call):\\n+ \\\"\\\"\\\"Relative path focus failure: no anchor (no drift to restore), so\\n+ just `focus`, then halt. Type MUST NOT run.\\n+\\n+ The absolute-path equivalent (with anchor + restore) is covered by\\n+ test_type_text_absolute_path_focus_failure_skips_type_and_restores.\\n+ \\\"\\\"\\\"\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ mock_call.side_effect = [\\n+ _make_result(\\\"\\\\x1b[31mfocus: No such element\\\\x1b[0m\\\"), # focus fails\\n+ _make_result(\\\"✓ Typed\\\"), # should NOT be reached\\n+ ]\\n+\\n+ result = backend.type_text(\\\"stale_input\\\", \\\"secret_password\\\", session=sess)\\n+\\n+ # Only the focus call was made; the focus result was returned.\\n+ assert mock_call.call_count == 1\\n+ assert mock_call.call_args_list[0].args[0] == \\\"focus stale_input\\\"\\n+ # The focus result is parsed (CLI consumes dicts, not CallToolResult).\\n+ assert result == {\\n+ \\\"error\\\": \\\"\\\\x1b[31mfocus: No such element\\\\x1b[0m\\\",\\n+ \\\"output\\\": \\\"\\\\x1b[31mfocus: No such element\\\\x1b[0m\\\",\\n+ }\\n+\\n+\\n+def test_type_text_raises_without_session_in_non_daemon_mode():\\n+ \\\"\\\"\\\"Non-daemon mode: the two halves must share a lane via group_id,\\n+ which requires a session. Without one, raise.\\n+ \\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"session\\\"):\\n+ backend.type_text(\\n+ \\\"search_input\\\", \\\"text\\\", use_daemon=False, session=None,\\n+ )\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_type_text_allows_no_session_in_daemon_mode(mock_call):\\n+ \\\"\\\"\\\"Daemon mode shares lane via the persistent connection — session\\n+ isn't required. Locks in the contract Copilot flagged.\\n+ \\\"\\\"\\\"\\n+ mock_call.return_value = _make_result(\\\"✓\\\\n[lane: 1]\\\")\\n+\\n+ # No exception. Relative path → two calls (focus + type).\\n+ backend.type_text(\\\"search_input\\\", \\\"hello\\\", use_daemon=True, session=None)\\n+\\n+ assert mock_call.call_count == 2\\n+ assert mock_call.call_args_list[0].args[0] == \\\"focus search_input\\\"\\n+ assert mock_call.call_args_list[1].args[0] == \\\"type hello\\\"\\n+\\n+\\n+def test_type_text_raises_with_empty_path():\\n+ with pytest.raises(ValueError, match=\\\"input path is required\\\"):\\n+ backend.type_text(\\\"\\\", \\\"text\\\", session=_make_session())\\n+ with pytest.raises(ValueError, match=\\\"input path is required\\\"):\\n+ backend.type_text(\\\"/\\\", \\\"text\\\", session=_make_session())\\n+\\n+\\n+def test_type_text_rejects_newline_in_text():\\n+ \\\"\\\"\\\"``\\\\\\\\n`` in text would inject a new DOMShell command — must raise.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.type_text(\\\"search_input\\\", \\\"line1\\\\nline2\\\")\\n+\\n+\\n+def test_type_text_rejects_carriage_return_in_text():\\n+ \\\"\\\"\\\"``\\\\\\\\r`` is just as dangerous as ``\\\\\\\\n`` for DOMShell's line splitter.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.type_text(\\\"search_input\\\", \\\"line1\\\\rline2\\\")\\n+\\n+\\n+def test_type_text_rejects_newline_in_path():\\n+ \\\"\\\"\\\"A newline in the path argument also injects — guard both fields.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.type_text(\\\"input\\\\nclick /admin\\\", \\\"anything\\\")\\n+\\n+\\n+# ── grep: newline guard on rooted multi-step path ─────────────────────\\n+\\n+\\n+def test_grep_rejects_newline_in_path():\\n+ \\\"\\\"\\\"Rooted grep interpolates path into a multi-line cd/grep/cd — reject newlines.\\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\\nclick /admin\\\", prev=\\\"/\\\")\\n+\\n+\\n+def test_grep_rejects_newline_in_pattern():\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.grep(\\\"Login\\\\nclick /admin\\\", path=\\\"/main\\\", prev=\\\"/\\\")\\n+\\n+\\n+def test_grep_rejects_hyphen_prefixed_pattern():\\n+ \\\"\\\"\\\"DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ so the grep wrapper can't pass hyphen-prefixed search strings as\\n+ patterns. The wrapper raises ValueError with a clear message so\\n+ users see the limitation immediately rather than getting DOMShell's\\n+ generic Usage reply. Real fix needs upstream parseArgs ``--``\\n+ support; tracked upstream. (@yuh-yang R3 blocker 3, Path B.)\\n+ \\\"\\\"\\\"\\n+ with pytest.raises(ValueError, match=\\\"patterns starting with '-'\\\"):\\n+ backend.grep(\\\"-disabled\\\")\\n+ with pytest.raises(ValueError, match=\\\"patterns starting with '-'\\\"):\\n+ backend.grep(\\\"--content\\\")\\n+\\n+\\n+def test_grep_rejects_newline_in_prev():\\n+ with pytest.raises(ValueError, match=\\\"newline\\\"):\\n+ backend.grep(\\\"Login\\\", path=\\\"/main\\\", prev=\\\"/\\\\nclick /admin\\\")\\n+\\n+\\n+# ── Centralized newline guard in _q ──────────────────────────────────\\n+#\\n+# The per-wrapper _assert_single_line calls above cover type_text and\\n+# rooted grep with field-named error messages. The newline check inside\\n+# _q itself catches the same class of injection for every OTHER wrapper\\n+# that flows user input through the quoting layer (open_url, click, cd,\\n+# cat, unrooted grep, etc.) — without needing a per-call guard at each\\n+# site.\\n+\\n+\\n+def test_q_rejects_line_feeds():\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend._q(\\\"foo\\\\nbar\\\")\\n+\\n+\\n+def test_q_rejects_carriage_returns():\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend._q(\\\"foo\\\\rbar\\\")\\n+\\n+\\n+def test_q_accepts_normal_strings():\\n+ \\\"\\\"\\\"Plain strings pass through to shlex.quote unchanged.\\\"\\\"\\\"\\n+ assert backend._q(\\\"simple\\\") == \\\"simple\\\"\\n+ assert backend._q(\\\"hello world\\\") == \\\"'hello world'\\\"\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_unrooted_grep_pattern_rejects_newlines(mock_call):\\n+ \\\"\\\"\\\"The unrooted grep path was not field-guarded — _q catches it.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.grep(\\\"evil\\\\nclick /admin\\\")\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_open_url_rejects_newlines(mock_call):\\n+ \\\"\\\"\\\"open_url has no per-call _assert_single_line — _q must catch it.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.open_url(\\\"https://example.com\\\\nclick /admin\\\")\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_click_rejects_newlines(mock_call):\\n+ \\\"\\\"\\\"click is covered structurally by _q without a per-call guard.\\\"\\\"\\\"\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.click(\\\"/main/button[0]\\\\nclick /admin\\\")\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_cd_rejects_newlines(mock_call):\\n+ mock_call.return_value = {}\\n+ with pytest.raises(ValueError, match=\\\"[Nn]ewline\\\"):\\n+ backend.cd(\\\"/main\\\\nclick /admin\\\")\\n+\\n+\\n+# ── DOMShell lane persistence across _call_execute calls ─────────────\\n+#\\n+# DOMShell 2.x assigns a fresh lane (Chrome tab-group) to every new MCP\\n+# session. In non-daemon mode each _call_execute opens its own stdio\\n+# ClientSession, so without explicit group_id every command would land\\n+# in a brand-new lane and lose browser state from the previous call.\\n+# The fix: parse the trailing \\\"[lane: <id>]\\\" marker DOMShell appends to\\n+# each reply, store it on the harness Session, and pass group_id=<id>\\n+# on every subsequent call.\\n+\\n+\\n+def _make_session(\\n+ working_dir: str = \\\"/\\\",\\n+ daemon_mode: bool = False,\\n+ lane_id=None,\\n+):\\n+ \\\"\\\"\\\"Build a minimal session fixture compatible with the backend's\\n+ ``getattr``-style access (working_dir, daemon_mode, domshell_lane_id).\\\"\\\"\\\"\\n+ return SimpleNamespace(\\n+ working_dir=working_dir,\\n+ daemon_mode=daemon_mode,\\n+ domshell_lane_id=lane_id,\\n+ )\\n+\\n+\\n+def _make_result(text: str):\\n+ \\\"\\\"\\\"Build a fake CallToolResult whose ``content[0].text`` is ``text``.\\\"\\\"\\\"\\n+ return SimpleNamespace(content=[SimpleNamespace(text=text)])\\n+\\n+\\n+# ── _extract_lane_id ────────────────────────────────────────────────\\n+\\n+\\n+def test_extract_lane_id_parses_trailing_marker():\\n+ assert backend._extract_lane_id(_make_result(\\\"✓ ls done\\\\n[lane: 12345]\\\")) == \\\"12345\\\"\\n+\\n+\\n+def test_extract_lane_id_handles_trailing_whitespace():\\n+ assert backend._extract_lane_id(_make_result(\\\"✓ ls done\\\\n[lane: lane-abc]\\\\n\\\")) == \\\"lane-abc\\\"\\n+\\n+\\n+def test_extract_lane_id_ignores_shared_marker():\\n+ \\\"\\\"\\\"`[lane: shared]` is DOMShell's no-isolation sentinel — must not pin to it.\\\"\\\"\\\"\\n+ assert backend._extract_lane_id(_make_result(\\\"✓ ls done\\\\n[lane: shared]\\\")) is None\\n+\\n+\\n+def test_extract_lane_id_returns_none_when_marker_absent():\\n+ assert backend._extract_lane_id(_make_result(\\\"✓ ls done\\\")) is None\\n+\\n+\\n+def test_extract_lane_id_returns_none_for_empty_text():\\n+ assert backend._extract_lane_id(_make_result(\\\"\\\")) is None\\n+\\n+\\n+def test_extract_lane_id_returns_none_when_content_missing():\\n+ assert backend._extract_lane_id(SimpleNamespace()) is None\\n+\\n+\\n+# ── lane capture + propagation ──────────────────────────────────────\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_first_call_passes_wrapper_signature_and_captures_lane(mock_call):\\n+ \\\"\\\"\\\"A session with no stored lane: the wrapper passes (command,\\n+ use_daemon, session=sess) into ``_call_execute``; the wire-format\\n+ ``group_id`` selection (``\\\"new\\\"`` for non-daemon first calls,\\n+ ``\\\"shared\\\"`` for daemon-mode-no-session) happens inside\\n+ ``_call_execute`` itself and is covered by the dedicated\\n+ wire-payload tests below. This test only asserts the wrapper-level\\n+ call signature plus the ``_capture_lane`` parser hookup.\\n+ \\\"\\\"\\\"\\n+ sess = Session() # domshell_lane_id starts as None\\n+ mock_call.return_value = _make_result(\\\"✓\\\\n[lane: 12345]\\\")\\n+\\n+ backend.click(\\\"submit_btn\\\", session=sess)\\n+\\n+ # The session= kwarg the wrapper passes is the Session object itself;\\n+ # _call_execute is responsible for translating session.domshell_lane_id\\n+ # into the wire-format group_id. We only assert the call signature here.\\n+ assert mock_call.call_args == call(\\\"click submit_btn\\\", False, session=sess)\\n+ # _call_execute is mocked, so we exercise _capture_lane directly to\\n+ # verify the parser hookup that the real _call_execute would do.\\n+ backend._capture_lane(sess, mock_call.return_value)\\n+ assert sess.domshell_lane_id == \\\"12345\\\"\\n+\\n+\\n+def test_capture_lane_updates_session():\\n+ sess = Session()\\n+ backend._capture_lane(sess, _make_result(\\\"✓\\\\n[lane: lane-XYZ]\\\"))\\n+ assert sess.domshell_lane_id == \\\"lane-XYZ\\\"\\n+\\n+\\n+def test_capture_lane_no_op_when_session_is_none():\\n+ \\\"\\\"\\\"Direct backend callers without a session must not crash.\\\"\\\"\\\"\\n+ backend._capture_lane(None, _make_result(\\\"✓\\\\n[lane: 12345]\\\")) # no exception\\n+\\n+\\n+def test_capture_lane_no_op_when_marker_missing():\\n+ sess = Session()\\n+ sess.domshell_lane_id = \\\"preexisting\\\"\\n+ backend._capture_lane(sess, _make_result(\\\"✓ done\\\"))\\n+ # No marker → don't clobber the previously-captured lane.\\n+ assert sess.domshell_lane_id == \\\"preexisting\\\"\\n+\\n+\\n+def test_capture_lane_ignores_shared_marker():\\n+ sess = Session()\\n+ sess.domshell_lane_id = \\\"preexisting\\\"\\n+ backend._capture_lane(sess, _make_result(\\\"✓\\\\n[lane: shared]\\\"))\\n+ assert sess.domshell_lane_id == \\\"preexisting\\\"\\n+\\n+\\n+# ── End-to-end: lane reuse on subsequent calls ───────────────────────\\n+\\n+\\n+def test_call_execute_includes_group_id_when_lane_is_set():\\n+ \\\"\\\"\\\"When session.domshell_lane_id is set, _call_execute sends it as group_id.\\n+\\n+ We bypass the stdio_client / ClientSession plumbing entirely by patching\\n+ them — what we want to assert is the arguments dict that gets passed to\\n+ ``call_tool``.\\n+ \\\"\\\"\\\"\\n+ sess = Session()\\n+ sess.domshell_lane_id = \\\"lane-7\\\"\\n+\\n+ fake_tool = AsyncMock(return_value=_make_result(\\\"✓\\\\n[lane: lane-7]\\\"))\\n+\\n+ fake_mcp_session = AsyncMock()\\n+ fake_mcp_session.__aenter__.return_value = fake_mcp_session\\n+ fake_mcp_session.__aexit__.return_value = None\\n+ fake_mcp_session.initialize = AsyncMock()\\n+ fake_mcp_session.call_tool = fake_tool\\n+\\n+ fake_stdio = AsyncMock()\\n+ fake_stdio.__aenter__.return_value = (object(), object())\\n+ fake_stdio.__aexit__.return_value = None\\n+\\n+ with patch.object(backend, \\\"stdio_client\\\", return_value=fake_stdio), \\\\\\n+ patch.object(backend, \\\"ClientSession\\\", return_value=fake_mcp_session), \\\\\\n+ patch.object(backend, \\\"_build_server_args\\\", return_value=[]):\\n+ import asyncio as _aio\\n+ _aio.run(backend._call_execute(\\\"ls /\\\", session=sess))\\n+\\n+ name, arguments = fake_tool.call_args.args\\n+ assert name == \\\"domshell_execute\\\"\\n+ assert arguments == {\\\"command\\\": \\\"ls /\\\", \\\"group_id\\\": \\\"lane-7\\\"}\\n+\\n+\\n+def test_call_execute_passes_group_id_new_when_lane_is_none():\\n+ \\\"\\\"\\\"First-call shape: no stored lane → ``group_id=\\\"new\\\"``; DOMShell\\n+ creates an isolated lane and returns the id, which we capture for\\n+ next time.\\n+\\n+ Migration note (PR #308 follow-up to DOMShell 2.0.2): we used to omit\\n+ ``group_id`` on the first call entirely, which DOMShell 2.x mapped\\n+ to a fresh lane silently. 2.0.2 deprecated that path — omitting now\\n+ emits a [DEPRECATION] warning on every reply (will be a hard error\\n+ in 3.0.0). Passing ``\\\"new\\\"`` makes the intent explicit and silences\\n+ the warning.\\n+ \\\"\\\"\\\"\\n+ sess = Session() # lane is None\\n+ fake_tool = AsyncMock(return_value=_make_result(\\\"✓\\\\n[lane: brand-new]\\\"))\\n+\\n+ fake_mcp_session = AsyncMock()\\n+ fake_mcp_session.__aenter__.return_value = fake_mcp_session\\n+ fake_mcp_session.__aexit__.return_value = None\\n+ fake_mcp_session.initialize = AsyncMock()\\n+ fake_mcp_session.call_tool = fake_tool\\n+\\n+ fake_stdio = AsyncMock()\\n+ fake_stdio.__aenter__.return_value = (object(), object())\\n+ fake_stdio.__aexit__.return_value = None\\n+\\n+ with patch.object(backend, \\\"stdio_client\\\", return_value=fake_stdio), \\\\\\n+ patch.object(backend, \\\"ClientSession\\\", return_value=fake_mcp_session), \\\\\\n+ patch.object(backend, \\\"_build_server_args\\\", return_value=[]):\\n+ import asyncio as _aio\\n+ _aio.run(backend._call_execute(\\\"ls /\\\", session=sess))\\n+\\n+ arguments = fake_tool.call_args.args[1]\\n+ assert arguments.get(\\\"group_id\\\") == \\\"new\\\"\\n+ # The auto-assigned lane gets captured for next time.\\n+ assert sess.domshell_lane_id == \\\"brand-new\\\"\\n+\\n+\\n+def test_call_execute_daemon_no_session_first_call_passes_new_and_captures_lane():\\n+ \\\"\\\"\\\"Daemon mode + no session, first call: passes ``group_id=\\\"new\\\"``\\n+ and captures the lane id from the response into the module-level\\n+ ``_daemon_lane_id`` for subsequent calls. Replaces the previous\\n+ ``\\\"shared\\\"`` behavior (commit 99d1182) per @yuh-yang R3 blocker 2.\\n+\\n+ The R2 \\\"shared\\\" branch claimed per-connection-default stickiness\\n+ that holds when the persistent daemon connection is alive but\\n+ breaks in the fall-back spawn path (each call gets its own\\n+ per-MCP-session default lane). The captured-id approach works\\n+ consistently across both paths because Chrome tab-group ids\\n+ persist at the browser level, regardless of MCP session.\\n+ \\\"\\\"\\\"\\n+ # Reset module state (other tests may have populated it).\\n+ backend._daemon_lane_id = None\\n+\\n+ try:\\n+ fake_tool = AsyncMock(\\n+ return_value=_make_result(\\\"✓\\\\n[lane: daemon-captured-99]\\\")\\n+ )\\n+ fake_mcp_session = AsyncMock()\\n+ fake_mcp_session.call_tool = fake_tool\\n+\\n+ with patch.object(backend, \\\"_daemon_session\\\", fake_mcp_session):\\n+ import asyncio as _aio\\n+ _aio.run(backend._call_execute(\\\"ls /\\\", use_daemon=True, session=None))\\n+\\n+ name, arguments = fake_tool.call_args.args\\n+ assert name == \\\"domshell_execute\\\"\\n+ assert arguments.get(\\\"group_id\\\") == \\\"new\\\"\\n+ assert backend._daemon_lane_id == \\\"daemon-captured-99\\\"\\n+ finally:\\n+ backend._daemon_lane_id = None\\n+\\n+\\n+def test_call_execute_daemon_no_session_subsequent_calls_reuse_captured_lane():\\n+ \\\"\\\"\\\"Once ``_daemon_lane_id`` is set, daemon-no-session calls pass\\n+ that id as ``group_id`` instead of ``\\\"new\\\"`` — preserves browser\\n+ state across calls regardless of whether the daemon's stdio is\\n+ alive or whether we've fallen back to fresh spawns per call.\\n+ Capture stays stable; no clobber on subsequent calls.\\n+ \\\"\\\"\\\"\\n+ backend._daemon_lane_id = \\\"preexisting-77\\\"\\n+\\n+ try:\\n+ fake_tool = AsyncMock(\\n+ return_value=_make_result(\\\"✓\\\\n[lane: preexisting-77]\\\")\\n+ )\\n+ fake_mcp_session = AsyncMock()\\n+ fake_mcp_session.call_tool = fake_tool\\n+\\n+ with patch.object(backend, \\\"_daemon_session\\\", fake_mcp_session):\\n+ import asyncio as _aio\\n+ _aio.run(backend._call_execute(\\\"ls /\\\", use_daemon=True, session=None))\\n+\\n+ name, arguments = fake_tool.call_args.args\\n+ assert arguments.get(\\\"group_id\\\") == \\\"preexisting-77\\\"\\n+ # Capture stays the same — no clobber on subsequent calls.\\n+ assert backend._daemon_lane_id == \\\"preexisting-77\\\"\\n+ finally:\\n+ backend._daemon_lane_id = None\\n+\\n+\\n+def test_distinct_sessions_have_isolated_lanes():\\n+ \\\"\\\"\\\"Two sessions track lanes independently — no cross-contamination.\\\"\\\"\\\"\\n+ s1 = Session()\\n+ s2 = Session()\\n+ backend._capture_lane(s1, _make_result(\\\"✓\\\\n[lane: lane-A]\\\"))\\n+ backend._capture_lane(s2, _make_result(\\\"✓\\\\n[lane: lane-B]\\\"))\\n+ assert s1.domshell_lane_id == \\\"lane-A\\\"\\n+ assert s2.domshell_lane_id == \\\"lane-B\\\"\\n+\\n+\\n+# ── Keyword-only enforcement on session= ─────────────────────────────\\n+#\\n+# Only ``session`` is keyword-only; ``use_daemon`` stays positional so\\n+# pre-2.0.0 callers like ``ls(\\\"/\\\", True)`` keep working. ``grep`` is a\\n+# deliberate exception (fully keyword-only after the round-1 review).\\n+\\n+\\n+def test_session_is_keyword_only_on_click():\\n+ \\\"\\\"\\\"Trailing positional `None` is interpreted as a 3rd positional arg\\n+ that the wrapper doesn't accept — must raise TypeError.\\\"\\\"\\\"\\n+ with pytest.raises(TypeError):\\n+ backend.click(\\\"submit_btn\\\", False, None) # type: ignore[misc]\\n+\\n+\\n+def test_session_is_keyword_only_on_ls():\\n+ with pytest.raises(TypeError):\\n+ backend.ls(\\\"/\\\", False, None) # type: ignore[misc]\\n+\\n+\\n+def test_session_is_keyword_only_on_type_text():\\n+ with pytest.raises(TypeError):\\n+ backend.type_text(\\\"input\\\", \\\"hello\\\", False, None) # type: ignore[misc]\\n+\\n+\\n+def test_session_is_keyword_only_on_open_url():\\n+ with pytest.raises(TypeError):\\n+ backend.open_url(\\\"https://example.com\\\", False, None) # type: ignore[misc]\\n+\\n+\\n+# ── Positional `use_daemon` stays valid ──────────────────────────────\\n+#\\n+# These guard against accidentally pulling ``use_daemon`` behind the ``*``\\n+# in the future. Pre-2.0.0 calls written as ``ls(\\\"/\\\", True)`` must not\\n+# regress to ``TypeError``.\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_use_daemon_positional_on_ls(mock_call):\\n+ mock_call.return_value = _make_result(\\\"[lane: 1]\\\")\\n+ backend.ls(\\\"/\\\", True) # use_daemon=True positionally\\n+ # Absolute `/` with no session → 3-call sequence, use_daemon=True\\n+ # flows through all three calls.\\n+ assert mock_call.call_args_list == [\\n+ call(\\\"cd %here%\\\", True, session=None),\\n+ call(\\\"ls\\\", True, session=None),\\n+ call(\\\"cd %here%\\\", True, session=None),\\n+ ]\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_use_daemon_positional_on_click(mock_call):\\n+ mock_call.return_value = {}\\n+ backend.click(\\\"submit_btn\\\", True)\\n+ assert mock_call.call_args == call(\\\"click submit_btn\\\", True, session=None)\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_use_daemon_positional_on_reload(mock_call):\\n+ mock_call.return_value = {}\\n+ backend.reload(True)\\n+ assert mock_call.call_args == call(\\\"refresh\\\", True, session=None)\\n+\\n+\\n+@patch.object(backend, \\\"_call_execute\\\", new_callable=AsyncMock)\\n+def test_use_daemon_positional_on_type_text(mock_call):\\n+ \\\"\\\"\\\"Positional ``use_daemon`` flows through both halves of the split.\\n+\\n+ type_text now requires a session, so pass one explicitly.\\n+ \\\"\\\"\\\"\\n+ sess = _make_session(working_dir=\\\"/\\\")\\n+ mock_call.return_value = _make_result(\\\"✓\\\\n[lane: 1]\\\")\\n+ backend.type_text(\\\"input\\\", \\\"hello\\\", True, session=sess)\\n+ # Two calls (focus then type), both with use_daemon=True positionally.\\n+ assert mock_call.call_args_list == [\\n+ call(\\\"focus input\\\", True, session=sess),\\n+ call(\\\"type hello\\\", True, session=sess),\\n+ ]\\n\"\n },\n {\n \"comment\": \"The conditional `if path else \\\"ls\\\"` is effectively unreachable: `path` defaults to `\\\"/\\\"` and there is no documented contract that callers may pass an empty string (and an empty `path` would have a different DOMShell semantic — `ls` with no arg lists the server cwd, while `ls /` lists root). Either drop the branch and always emit `f\\\"ls {_q(path)}\\\"`, or change the default to `\\\"\\\"` and document that the empty-string case lists the lane's cwd. As written, this is dead code that hides intent.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -239,16 +354,17 @@ def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n >>> ls(\\\"/\\\")\\n {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n+ command = f\\\"ls {_q(path)}\\\" if path else \\\"ls\\\"\\n+ return asyncio.run(_call_execute(command, use_daemon, session=session))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"The error message embeds the full offending argument via `{arg!r}`. Because `_q` is the central guard against command injection, the rejected value can be arbitrarily large (e.g. a multi-line paste) and may be propagated into logs/telemetry verbatim. Consider truncating the echoed value (e.g. first ~80 chars + length) so error output stays bounded and avoids inadvertently logging large untrusted payloads.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -110,17 +117,103 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got: {arg!r}\\\"\\n+ )\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Preserve positional daemon arguments**\\n\\nAdding `*` here changes the public sync-wrapper API even though this module documents it as unchanged: downstream Python callers that previously used valid calls such as `ls('/', True)`, `click('/main/button', True)`, or `reload(True)` to enable daemon mode now get `TypeError` before any DOMShell call runs. The new `session` parameter can be keyword-only without forcing the existing `use_daemon` argument to become keyword-only across these wrappers.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -223,14 +333,19 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", *, use_daemon: bool = False, session: Any = None) -> dict:\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Map harness absolute paths before executing**\\n\\nWhen the normal flow opens a page and then runs `fs ls` (or the documented `fs ls /` / `fs cd /main`), the harness passes its internal absolute DOM path straight through as `ls /` or `cd /main`. DOMShell 2 treats `~`/`/` as the browser root, not the current tab's AX-tree root, so these commands list windows/tabs or fail instead of exploring page elements. Translate the harness's `/` and `/main/...` paths to DOMShell's current-tab-relative paths before building the command string.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -239,16 +358,16 @@ def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n >>> ls(\\\"/\\\")\\n {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(f\\\"ls {_q(path)}\\\", use_daemon, session=session))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Don't type after a failed focus command**\\n\\nIf `act type` is called with a stale or mistyped path while another input is focused, DOMShell's multi-line execute semantics continue after per-line errors, so the `type` line still runs even when `focus` failed and can enter text into the wrong element. Run `focus` and `type` as separate execute calls and only issue `type` after verifying focus succeeded, or use an atomic DOMShell command that fails as a unit.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -391,24 +549,17 @@ def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n \\n Returns:\\n Dict with action result\\n- \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n- )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n+ \\\"\\\"\\\"\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+ command = f\\\"focus {_q(path)}\\\\ntype {_q(text)}\\\"\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"This row is inconsistent with the implementation. `type_text` deliberately issues `focus` and `type` as **two separate `_call_execute` calls** (with an `_is_error` check in between) to avoid the unsafe focus/type race described in the wrapper's own docstring — it is not delivered as a single multi-line `focus\\\\\\\\ntype` command. Consider rewording this entry, e.g. `focus <path>` then (on success) `type <text>` (two calls), to match the actual wire behaviour and to avoid implying the same continue-on-error semantics that `fs grep <pat> <path>` uses.\",\n \"path\": \"browser/agent-harness/HARNESS.md\",\n \"hunk\": \"@@ -38,29 +38,41 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\\n ### Installation\\n \\n ```bash\\n-# Verify DOMShell is available\\n-npx @apireno/domshell --version\\n+# Verify DOMShell is available (2.0.0 or newer required)\\n+npx @apireno/domshell@2.0.0 --version\\n \\n # Install Chrome extension\\n # https://chromewebstore.google.com/detail/domshell\\n ```\\n \\n-### MCP Tools\\n-\\n-DOMShell exposes these MCP tools:\\n-\\n-| Tool | Description | CLI Command |\\n-|------|-------------|-------------|\\n-| `domshell_ls` | List directory contents | `fs ls` |\\n-| `domshell_cd` | Change directory | `fs cd` |\\n-| `domshell_cat` | Read element content | `fs cat` |\\n-| `domshell_grep` | Search for pattern | `fs grep` |\\n-| `domshell_click` | Click element | `act click` |\\n-| `domshell_type` | Type text | `act type` |\\n-| `domshell_open` | Navigate to URL | `page open` |\\n-| `domshell_reload` | Reload page | `page reload` |\\n-| `domshell_back` | Navigate back | `page back` |\\n-| `domshell_forward` | Navigate forward | `page forward` |\\n+**Minimum version: `@apireno/domshell@2.0.0`.** DOMShell 2.0.0 (May 2026)\\n+consolidated the MCP tool surface from 38 per-command tools to a single\\n+`domshell_execute` tool. The harness targets this consolidated tool, so no\\n+opt-in `--granular` server flag is required.\\n+\\n+### MCP Tool\\n+\\n+DOMShell 2.0.0+ exposes a single MCP tool:\\n+\\n+| Tool | Description |\\n+|------|-------------|\\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\\n+\\n+The harness builds command strings from the public CLI commands:\\n+\\n+| CLI Command | Command string sent to `domshell_execute` |\\n+|-------------|--------------------------------------------|\\n+| `fs ls <path>` | `ls <path>` |\\n+| `fs cd <path>` | `cd <path>` |\\n+| `fs cat <path>` | `cat <path>` |\\n+| `fs grep <pat>` | `grep <pat>` |\\n+| `fs grep <pat> <path>` | `cd <path>\\\\ngrep <pat>\\\\ncd <prev>` (single call) |\\n+| `act click <path>` | `click <path>` |\\n+| `act type <path> <text>` | `focus <path>\\\\ntype <text>` (single call) |\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/HARNESS.md b/browser/agent-harness/HARNESS.md\\nindex 7275a41a5a..2cd1ade02a 100644\\n--- a/browser/agent-harness/HARNESS.md\\n+++ b/browser/agent-harness/HARNESS.md\\n@@ -37,30 +37,61 @@ DOMShell is an npm package that exposes Chrome's Accessibility Tree via MCP:\\n \\n ### Installation\\n \\n+**Requires `@apireno/domshell` 2.0.2 or newer.** The harness uses\\n+`group_id=\\\"new\\\"` to declare lane intent explicitly on the first call of\\n+each session and reuses the captured lane id on subsequent calls (silences\\n+the deprecation warning that 2.0.2 added for omitted `group_id`; will\\n+become a hard error in DOMShell 3.0.0). For direct daemon-mode callers\\n+without a harness `Session`, the same scheme runs at module level — the\\n+first call captures a lane id into `_daemon_lane_id` and subsequent calls\\n+reuse it, preserving browser state across daemon-mode no-session calls\\n+(see `domshell_backend.py`'s `_daemon_lane_id` declaration for the\\n+stale-lane failure mode).\\n+\\n ```bash\\n-# Verify DOMShell is available\\n-npx @apireno/domshell --version\\n+npx @apireno/domshell --version # should report 2.0.2 or higher\\n \\n # Install Chrome extension\\n # https://chromewebstore.google.com/detail/domshell\\n ```\\n \\n-### MCP Tools\\n-\\n-DOMShell exposes these MCP tools:\\n-\\n-| Tool | Description | CLI Command |\\n-|------|-------------|-------------|\\n-| `domshell_ls` | List directory contents | `fs ls` |\\n-| `domshell_cd` | Change directory | `fs cd` |\\n-| `domshell_cat` | Read element content | `fs cat` |\\n-| `domshell_grep` | Search for pattern | `fs grep` |\\n-| `domshell_click` | Click element | `act click` |\\n-| `domshell_type` | Type text | `act type` |\\n-| `domshell_open` | Navigate to URL | `page open` |\\n-| `domshell_reload` | Reload page | `page reload` |\\n-| `domshell_back` | Navigate back | `page back` |\\n-| `domshell_forward` | Navigate forward | `page forward` |\\n+The standard `npx @apireno/domshell` invocation pulls the latest published\\n+version automatically; no manual pinning is required.\\n+\\n+DOMShell 2.0.0 (May 2026) consolidated the MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool. The harness targets\\n+this consolidated tool, so no opt-in `--granular` server flag is required.\\n+\\n+### MCP Tool\\n+\\n+DOMShell 2.0.2+ exposes a single MCP tool:\\n+\\n+| Tool | Description |\\n+|------|-------------|\\n+| `domshell_execute` | Runs a shell-style command string. Multi-line input is supported — each line runs in order in the same shell state. |\\n+\\n+The harness builds command strings from the public CLI commands. Harness\\n+absolute paths (leading `/`) are anchored at the tab root via\\n+`cd %here%` since DOMShell's lane cwd may have drifted; relative paths\\n+are passed through unchanged.\\n+\\n+| CLI Command (path is absolute) | Command string sent to `domshell_execute` |\\n+|--------------------------------|--------------------------------------------|\\n+| `fs ls /<sub>` | `cd %here%/<sub>` then bare `ls`, then `cd <restore>` (single multi-line call) |\\n+| `fs cd /<sub>` | `cd %here%/<sub>` (single line — `cd` is the desired new state) |\\n+| `fs cat /<sub>` | `cd %here%`, `cat <sub>`, `cd <restore>` (single multi-line call) |\\n+| `fs grep <pat>` | `grep <pat>` (operates on lane cwd) |\\n+| `fs grep <pat> /<sub>` | `cd %here%/<sub>`, `grep <pat>`, `cd <restore>` (single multi-line call) |\\n+| `act click /<sub>` | `cd %here%`, `click <sub>`, `cd <restore>` (single multi-line call) |\\n+| `act type /<sub> <text>` | `cd %here%`, `focus <sub>`, `cd <restore>` — then, on success, `type <text>` (two calls, shared lane via `group_id`) |\\n+| `page open <url>` | `open <url>` |\\n+| `page reload` | `refresh` |\\n+| `page back` | `back` |\\n+| `page forward` | `forward` |\\n+\\n+`<restore>` resolves to `cd %here%/<harness-working-dir>` (or `cd %here%`\\n+when the harness is at the tab root) so the lane's cwd ends up where\\n+the harness expects.\\n \\n ## Key Design Decisions\\n \\n\"\n },\n {\n \"comment\": \"When `session is None` (e.g. direct backend callers, or `act type` paths that ever forget to pass `session=`), the `focus` and `type` calls run in two independent stdio MCP sessions with no `group_id` linkage — DOMShell will auto-assign a fresh lane to each, so the `type` call lands in a different lane than the `focus` and the focus state is lost (the comment on lines 652–656 only holds when a session pins the lane). Consider either (a) requiring `session` to be non-`None` for `type_text` (raise `ValueError` up-front), or (b) capturing the lane from `focus_result` into a transient local session-like object when the caller passed `None`, so the second call inherits the same `group_id`.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -335,80 +560,108 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\\n >>> open_url(\\\"https://example.com\\\")\\n {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ return asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+ translated_path = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an element name is required — cannot focus the tab root.\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- return asyncio.run(_focus_and_type())\\n+ # Relies on DOMShell serializing commands within a lane: the `type`\\n+ # call below cannot be preempted by another agent's `focus` on the\\n+ # same lane between these two _call_execute boundaries. If that\\n+ # contract ever changes upstream, this needs to revert to a single\\n+ # multi-line call with an alternative safety story.\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ return focus_result # don't type — focus didn't land\\n+ return asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"`_q` and `_assert_single_line` now both reject `\\\\\\\\n`/`\\\\\\\\r` with very similar error text but slightly different wording, and several wrappers (`grep`, `type_text`) call `_assert_single_line` immediately before `_q`, which is redundant — `_q` would raise on the same input one line later. Consider having `_assert_single_line` be the single source of truth (called from inside `_q`, or called by wrappers that want field-named errors with `_q` no longer duplicating the check), so future wrappers can't drift between two subtly different guards. Optional.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -110,17 +117,156 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"`_translate_path` only strips a single leading `/`, so a harness path like `\\\\\\\"//main\\\\\\\"` (which `fs.change_directory` can produce via the `rstrip(\\\\\\\"/\\\\\\\") + \\\\\\\"/\\\\\\\" + path` join when `path` already starts with `/`) becomes `\\\\\\\"/main\\\\\\\"` after translation and is then shell-quoted and shipped to DOMShell as an absolute browser-root path — exactly the bug the `~/`-vs-`/` translation is meant to prevent. Consider using `harness_path.lstrip(\\\\\\\"/\\\\\\\")` (and treating an all-slash input as the lane-cwd sentinel) so any number of leading slashes collapses to a lane-relative path.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -110,17 +117,156 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> str:\\n+ \\\"\\\"\\\"Translate a harness DOM path to a DOMShell command path.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``~/`` (and bare ``/``) as the BROWSER root — windows and tabs.\\n+ Sending ``ls /`` verbatim would list tabs, not page elements. Strip\\n+ the leading ``/`` so harness ``/main`` becomes DOMShell ``main``\\n+ (relative to the lane's cwd, which IS the focused tab's AX root once\\n+ ``page open`` has put the lane inside the tab).\\n+\\n+ - ``\\\"\\\"`` and ``\\\"/\\\"`` → ``\\\"\\\"`` (signal: operate on lane cwd; the\\n+ wrappers turn this into a bare command, e.g. ``ls`` or ``cd %here%``).\\n+ - ``\\\"/main\\\"`` → ``\\\"main\\\"``\\n+ - ``\\\"/main/article\\\"`` → ``\\\"main/article\\\"``\\n+ - ``\\\"main\\\"``, ``\\\"..\\\"``, ``\\\".\\\"`` → passed through unchanged.\\n+ \\\"\\\"\\\"\\n+ if not harness_path or harness_path == \\\"/\\\":\\n+ return \\\"\\\"\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path[1:]\\n+ return harness_path\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Root absolute harness paths before stripping the slash**\\n\\nWhen the lane cwd is no longer the tab root (for example `fs cd /main` pins the DOMShell lane at `/main`, then `fs ls` uses `session.working_dir == \\\"/main\\\"`), stripping the absolute harness path to `main` makes DOMShell resolve it relative to the current cwd and target `/main/main` instead of `/main`. This affects ordinary absolute operations after any `cd`; absolute harness paths need to be executed from the tab root (e.g. via `%here%`) or otherwise encoded as root-relative before being sent to DOMShell.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -110,17 +117,156 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> str:\\n+ \\\"\\\"\\\"Translate a harness DOM path to a DOMShell command path.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``~/`` (and bare ``/``) as the BROWSER root — windows and tabs.\\n+ Sending ``ls /`` verbatim would list tabs, not page elements. Strip\\n+ the leading ``/`` so harness ``/main`` becomes DOMShell ``main``\\n+ (relative to the lane's cwd, which IS the focused tab's AX root once\\n+ ``page open`` has put the lane inside the tab).\\n+\\n+ - ``\\\"\\\"`` and ``\\\"/\\\"`` → ``\\\"\\\"`` (signal: operate on lane cwd; the\\n+ wrappers turn this into a bare command, e.g. ``ls`` or ``cd %here%``).\\n+ - ``\\\"/main\\\"`` → ``\\\"main\\\"``\\n+ - ``\\\"/main/article\\\"`` → ``\\\"main/article\\\"``\\n+ - ``\\\"main\\\"``, ``\\\"..\\\"``, ``\\\".\\\"`` → passed through unchanged.\\n+ \\\"\\\"\\\"\\n+ if not harness_path or harness_path == \\\"/\\\":\\n+ return \\\"\\\"\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path[1:]\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Preserve focus for direct type_text callers**\\n\\nFor public callers that use `type_text(...)` without passing a harness `Session` in non-daemon mode, this focus call and the later `type` call open separate MCP sessions/lanes, and the lane from `focus` is not captured because `session` is `None`. That regresses the previous direct-wrapper behavior where focus and type shared one MCP session, so the text can be sent in a fresh lane with no focused element; create a temporary lane/session for this path or keep the two commands on one MCP session.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -335,80 +560,108 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\\n >>> open_url(\\\"https://example.com\\\")\\n {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ return asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+ translated_path = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an element name is required — cannot focus the tab root.\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- return asyncio.run(_focus_and_type())\\n+ # Relies on DOMShell serializing commands within a lane: the `type`\\n+ # call below cannot be preempted by another agent's `focus` on the\\n+ # same lane between these two _call_execute boundaries. If that\\n+ # contract ever changes upstream, this needs to revert to a single\\n+ # multi-line call with an alternative safety story.\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"**<sub><sub></sub></sub> Detect errors inside wrapped absolute focus**\\n\\nFor absolute paths, the focus step is still wrapped as a multi-line `cd …\\\\nfocus …\\\\ncd …` command. In the stale absolute-path case (for example `act type /main/missing secret`), the leading `cd` and trailing restore can succeed even though the middle `focus` fails; `_is_error` only catches `isError` or text that starts with `error`, so this can miss the focus failure and proceed to the following `type` call into whatever element was already focused. Fresh evidence after the earlier focus-safety comment is that the new split still keeps absolute focus inside a multi-line wrapper.\\n\\nUseful? React with 👍 / 👎.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -335,80 +673,127 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\\n >>> open_url(\\\"https://example.com\\\")\\n {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ return asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # A session is required: the focus and type halves split across two\\n+ # _call_execute calls, and without `session.domshell_lane_id` the\\n+ # second call would land in a different DOMShell lane and miss the\\n+ # focus state from the first.\\n+ if session is None:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required so the focus and type \\\"\\n+ \\\"calls share a DOMShell lane. Otherwise the focus state from the \\\"\\n+ \\\"first call would not apply to the second.\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # Relies on DOMShell serializing commands within a lane: the `type`\\n+ # call below cannot be preempted by another agent's `focus` on the\\n+ # same lane between these two _call_execute boundaries. If that\\n+ # contract ever changes upstream, this needs to revert to a single\\n+ # multi-line call with an alternative safety story.\\n+ if is_absolute:\\n+ # Anchor + focus + restore as one multi-line call, so the focus\\n+ # lands against the tab root regardless of lane cwd drift.\\n+ focus_cmd = _wrap_absolute(f\\\"focus {_q(translated_path)}\\\", session)\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"Making `session` mandatory for `type_text` is a behavioral breaking change relative to the pre-migration signature (`type_text(path, text, use_daemon=False)`), and the rationale (lane sharing) doesn't actually apply when `use_daemon=True` — in daemon mode both halves go through the same persistent `_daemon_session` and would share state without an explicit `group_id`. Consider only requiring `session` for the non-daemon path (e.g., `if session is None and not use_daemon:`), or document this in the wrapper's `Raises:` as an unconditional requirement and call it out in the PR/HARNESS notes since callers programmatically using the backend directly will now get a `ValueError` instead of working as before.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -335,80 +694,156 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\\n >>> open_url(\\\"https://example.com\\\")\\n {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ return asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # A session is required: the focus and type halves split across two\\n+ # _call_execute calls, and without `session.domshell_lane_id` the\\n+ # second call would land in a different DOMShell lane and miss the\\n+ # focus state from the first.\\n+ if session is None:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required so the focus and type \\\"\\n+ \\\"calls share a DOMShell lane. Otherwise the focus state from the \\\"\\n+ \\\"first call would not apply to the second.\\\"\\n )\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"This docstring example hard-codes `v2.0.0`, but `is_available()` returns whichever version `npx @apireno/domshell --version` reports at runtime, which may be `>=2.0.0`. Consider either using an ellipsis (e.g. `(True, \\\"DOMShell vX.Y.Z is available\\\")`) or wording it as \\\"v2.0.0 or later\\\" so the example doesn't suggest the function pins to that specific version.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -78,7 +85,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell v2.0.0 is available\\\")\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"The daemon-failure path now swallows the exception entirely with no logging, so an operator debugging why the daemon keeps dying and respawning will have no record of the underlying error (the previous `as e` was unused but at least left the value available). Consider logging the exception (e.g. `logging.warning(\\\"DOMShell daemon call failed, respawning: %s\\\", e)`) before falling back so silent daemon thrash is diagnosable.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -130,12 +372,26 @@ async def _call_tool(\\n \\\"\\\"\\\"\\n global _daemon_session, _daemon_read, _daemon_write\\n \\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Reuse the previously-captured DOMShell lane so this call lands in the\\n+ # same Chrome tab-group as the prior commands in this session. Without\\n+ # this, every fresh stdio ClientSession would be assigned a brand-new\\n+ # lane and `page open` / `fs ls` etc. would run in disjoint browser\\n+ # state. The very first call leaves group_id unset so DOMShell\\n+ # auto-assigns; _capture_lane stores that id on the session for the\\n+ # next call.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+\\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n return result\\n- except Exception as e:\\n+ except Exception:\\n # Daemon died, fall back to spawning new server\\n await _stop_daemon()\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"Each `asyncio.run` call tears down and rebuilds an event loop, and in non-daemon mode each `_call_execute` also opens a fresh stdio MCP session/process — so the absolute-path branch of `type_text` now spawns up to four DOMShell server processes per call (anchor, focus, type, restore) where the prior implementation used one. This is intentional for the safety split, but consider either (a) refactoring into a single `async def` driver that runs the four steps under one `asyncio.run` and one shared `ClientSession`, or (b) documenting the per-call overhead so users aren't surprised by the latency increase on absolute-path `act type` calls.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -335,80 +694,156 @@ def open_url(url: str, use_daemon: bool = False) -> dict:\\n >>> open_url(\\\"https://example.com\\\")\\n {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ return asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with navigation result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ return asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as two separate ``domshell_execute`` calls — ``focus``, check\\n+ for error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # A session is required: the focus and type halves split across two\\n+ # _call_execute calls, and without `session.domshell_lane_id` the\\n+ # second call would land in a different DOMShell lane and miss the\\n+ # focus state from the first.\\n+ if session is None:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required so the focus and type \\\"\\n+ \\\"calls share a DOMShell lane. Otherwise the focus state from the \\\"\\n+ \\\"first call would not apply to the second.\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ f\\\"cd {_here_path('')}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return anchor_result\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return focus_result\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # See daemon-path capture above for rationale — same\\n+ # logic applies on the fresh-spawn fall-back path,\\n+ # including the lock-guarded test-and-set.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n raise RuntimeError(\\n@@ -223,192 +676,524 @@ def daemon_started() -> bool:\\n return _daemon_session is not None\\n \\n \\n-# ── Sync wrappers for each DOMShell tool ─────────────────────────────\\n+# ── Sync wrappers for each DOMShell command ──────────────────────────\\n+#\\n+# Each wrapper builds a shell-style command string and dispatches to\\n+# `domshell_execute`. The public Python API is unchanged from the\\n+# pre-2.0.0 per-tool wrappers.\\n \\n-def ls(path: str = \\\"/\\\", use_daemon: bool = False) -> dict:\\n+def ls(path: str = \\\"/\\\", use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"List directory contents in the accessibility tree.\\n \\n Args:\\n path: Path in accessibility tree (e.g., \\\"/\\\", \\\"/main\\\", \\\"/main/div[0]\\\")\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'entries' key containing list of accessible elements\\n+ Dict shaped ``{\\\"entries\\\": [{\\\"name\\\": str, \\\"role\\\": \\\"\\\", \\\"path\\\": str}, ...],\\n+ \\\"raw\\\": str}`` (or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure —\\n+ wrappers reuse ``_parse_execute_result``'s contract).\\n+\\n+ ``name`` and ``path`` carry the raw line text from DOMShell's\\n+ ``ls`` output; directory entries currently include a trailing\\n+ ``/`` (cosmetic, see follow-up). ``role`` is always empty in\\n+ this round — structured role extraction will land alongside a\\n+ finer column parser in the follow-up.\\n \\n Example:\\n- >>> ls(\\\"/\\\")\\n- {\\\"path\\\": \\\"/\\\", \\\"entries\\\": [{\\\"name\\\": \\\"main\\\", \\\"role\\\": \\\"landmark\\\", ...}]}\\n+ >>> ls(\\\"/main\\\", session=session) # session required for absolute paths\\n+ {\\\"entries\\\": [{\\\"name\\\": \\\"heading_1\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"heading_1\\\"},\\n+ {\\\"name\\\": \\\"div/\\\", \\\"role\\\": \\\"\\\", \\\"path\\\": \\\"div/\\\"},\\n+ ...],\\n+ \\\"raw\\\": \\\"heading_1\\\\\\\\ndiv/\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_ls\\\", {\\\"options\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cd(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"ls\\\", session, use_daemon)\\n+ # Split-and-check: the anchor's success is load-bearing — if\\n+ # cd fails, ls would run in the wrong cwd and produce\\n+ # wrong-target results. Three separate _call_execute calls so\\n+ # we can _is_error-gate after the anchor and skip the operation\\n+ # cleanly. All share the persisted lane via session.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(translated), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"ls\\\")\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ # Best-effort restore — ls already ran; restore failure is\\n+ # cosmetic (next harness cd corrects any drift).\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+ if translated:\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"ls {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ else:\\n+ op = asyncio.run(_call_execute(\\\"ls\\\", use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"ls\\\")\\n+\\n+\\n+def cd(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Change directory in the accessibility tree.\\n \\n Args:\\n path: Target path\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with 'path' key confirming current location\\n+ Dict shaped ``{\\\"output\\\": str}`` on success, or\\n+ ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ Note no ``\\\"path\\\"`` key — ``fs.change_directory`` falls back to\\n+ the input ``path`` arg via ``result.get(\\\"path\\\", path)``, so the\\n+ harness's ``working_dir`` ends up at the requested target. The\\n+ ``output`` field carries DOMShell's raw confirmation text for\\n+ display.\\n \\n Example:\\n >>> cd(\\\"/main/div[0]\\\")\\n- {\\\"path\\\": \\\"/main/div[0]\\\", \\\"element\\\": {...}}\\n+ {\\\"output\\\": \\\"✓ Entered /main/div[0]\\\"}\\n+ >>> cd(\\\"/missing\\\")\\n+ {\\\"error\\\": \\\"cd: /missing: No such directory\\\",\\n+ \\\"output\\\": \\\"cd: /missing: No such directory\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cd\\\", {\\\"path\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def cat(path: str, use_daemon: bool = False) -> dict:\\n+ translated, is_absolute = _translate_path(path)\\n+ # cd is the one wrapper where the operation IS the new state — no\\n+ # following operation needs the anchored cwd, so no split-and-check\\n+ # and no restore. Absolute targets anchor via `cd %here%/<rest>` so\\n+ # the result is independent of the lane's current cwd.\\n+ if is_absolute:\\n+ command = _anchor_path_cmd(translated)\\n+ elif translated:\\n+ command = f\\\"cd {_q(translated)}\\\"\\n+ else:\\n+ # Bare/empty `cd` → back to tab root.\\n+ command = _anchor_path_cmd(\\\"\\\")\\n+ result = asyncio.run(_call_execute(command, use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"cd\\\")\\n+\\n+\\n+def cat(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Read element content from the accessibility tree.\\n \\n Args:\\n path: Path to element\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with element details including text, role, attributes\\n \\n Example:\\n- >>> cat(\\\"/main/button[0]\\\")\\n- {\\\"name\\\": \\\"Submit\\\", \\\"role\\\": \\\"button\\\", \\\"text\\\": \\\"Submit\\\", ...}\\n+ >>> cat(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"button: Submit\\\\\\\\n...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_cat\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n-\\n-\\n-def grep(pattern: str, use_daemon: bool = False) -> dict:\\n- \\\"\\\"\\\"Search for pattern in accessibility tree.\\n-\\n- Searches from the current working directory.\\n+ translated, is_absolute = _translate_path(path)\\n+ # Note: a falsy `translated` (root path `/` or empty string) is no\\n+ # longer rejected here. Pre-migration `fs cat` at the root surfaced\\n+ # DOMShell's own `Usage: cat <name>` error string; the round-5 guard\\n+ # converted that into a Python ValueError, which broke the\\n+ # `fs.read_element(session, \\\"\\\")` fall-through to `session.working_dir`\\n+ # for callers landed at `/`. Removed per @yuh-yang R3 review of\\n+ # `b684732` — `cat ''` reaches DOMShell, which has the same\\n+ # `if (!targetName)` check and returns its standard Usage error.\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"cat\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise run relative cat, restore. Anchor success is\\n+ # load-bearing — without it cat resolves the relative path\\n+ # against the wrong cwd.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"cat {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"cat\\\")\\n+\\n+\\n+def grep(\\n+ pattern: str,\\n+ *,\\n+ path: str = \\\"\\\",\\n+ prev: str = \\\"/\\\",\\n+ use_daemon: bool = False,\\n+ session: Any = None,\\n+) -> dict:\\n+ \\\"\\\"\\\"Search for pattern in the accessibility tree.\\n+\\n+ When ``path`` is provided and is not ``/``, the search is rooted at that\\n+ path: ``cd`` into it, ``grep``, then ``cd`` back to ``prev`` — sent as one\\n+ multi-line ``domshell_execute`` call so all three lines share an MCP\\n+ session (and therefore a DOMShell lane / cwd). Each ``_call_execute`` in\\n+ non-daemon mode opens a fresh stdio session that lands in its own\\n+ DOMShell 2.x lane, so splitting cd/grep/restore across separate calls\\n+ would lose the cwd between them. The trailing ``cd prev`` is delivered as\\n+ the final line of the same command and runs even if ``grep`` errors —\\n+ DOMShell's multi-line splitter continues past errors (see\\n+ `apireno/DOMShell#46 <https://github.com/apireno/DOMShell/issues/46>`_).\\n+\\n+ ``path``, ``prev``, and ``use_daemon`` are keyword-only to prevent silent\\n+ breakage of callers written against the pre-migration positional\\n+ signature ``grep(pattern, use_daemon)``.\\n \\n Args:\\n pattern: Text pattern to search for\\n+ path: Optional path to root the search at. If empty or \\\"/\\\", searches\\n+ from the server-side current working directory.\\n+ prev: Path to restore as cwd after the search. Used only when\\n+ ``path`` is provided. Defaults to \\\"/\\\".\\n use_daemon: Use persistent daemon connection if available\\n \\n Returns:\\n Dict with 'matches' key containing list of matching elements\\n \\n Example:\\n- >>> grep(\\\"Login\\\")\\n- {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"]}\\n+ >>> grep(\\\"Login\\\") # unrooted — session optional\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\", \\\"/main/link[1]\\\"], \\\"raw\\\": \\\"...\\\"}\\n+ >>> grep(\\\"Login\\\", path=\\\"/main\\\", session=session) # rooted → session required\\n+ {\\\"matches\\\": [\\\"/main/button[0]\\\"], \\\"raw\\\": \\\"...\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\n- \\\"domshell_grep\\\",\\n- {\\\"pattern\\\": pattern},\\n- use_daemon\\n+ _assert_single_line(\\\"pattern\\\", pattern)\\n+\\n+ # DOMShell's parseArgs treats any arg starting with \\\"-\\\" as a flag,\\n+ # with no \\\"--\\\" end-of-options separator and no \\\"-e <pattern>\\\" form\\n+ # (verified against src/background/index.ts:1692 in DOMShell 2.0.2).\\n+ # So `grep -r -- -foo` and `grep -r -e -foo` both fail at the\\n+ # kernel — neither survives parseArgs as a positional. Until\\n+ # DOMShell adds \\\"--\\\" support in a future release, raise a clear\\n+ # Python-side error so the user sees the limitation immediately\\n+ # instead of getting DOMShell's generic \\\"Usage:\\\" reply.\\n+ # (yuh-yang R3 blocker 3, Path B — Python-side soft validation.)\\n+ if pattern.startswith(\\\"-\\\"):\\n+ raise ValueError(\\n+ f\\\"grep: patterns starting with '-' are not supported by the \\\"\\n+ f\\\"current DOMShell parser — it would parse {pattern!r} as a \\\"\\n+ f\\\"flag rather than as the search pattern. Known limitation \\\"\\n+ f\\\"tracked upstream; will be resolved when DOMShell's \\\"\\n+ f\\\"parseArgs adds `--` end-of-options support. Workaround: \\\"\\n+ f\\\"drop the leading '-' from the pattern if possible, or \\\"\\n+ f\\\"wait for the upstream fix.\\\"\\n+ )\\n+ translated_path, path_abs = _translate_path(path)\\n+ if not translated_path:\\n+ # Unrooted grep — operate on lane cwd, no cd, no restore.\\n+ # `-r` preserves the pre-migration semantic: the old\\n+ # `domshell_grep` tool defaulted to recursive=True (walk all\\n+ # descendants). Plain `grep <pat>` in DOMShell shell only\\n+ # searches the cwd's immediate children, missing nested matches.\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n+\\n+ # `path` was already newline-guarded by `_translate_path` above\\n+ # (round 6's translation-boundary check) so the field-named\\n+ # `_assert_single_line(\\\"path\\\", path)` we used to call here would be\\n+ # dead. `prev`, however, is only translated in the relative branch\\n+ # below — the absolute branch doesn't touch it. Keep the explicit\\n+ # field-named guard for `prev` so a newlined-prev kwarg raises a\\n+ # useful error regardless of which branch consumes it.\\n+ _assert_single_line(\\\"prev\\\", prev)\\n+\\n+ # Both rooted branches (absolute and relative) issue 3 separate\\n+ # `_call_execute` calls — anchor cd, grep, restore cd — and depend on\\n+ # all three landing in the same DOMShell lane. Check session here so\\n+ # the requirement applies uniformly.\\n+ _require_session_for_split_check(\\\"grep\\\", session, use_daemon)\\n+\\n+ # Split-and-check. Anchor success is load-bearing: if the cd\\n+ # to the rooting path fails, grep would search against the wrong\\n+ # cwd and produce wrong-scope matches.\\n+ if path_abs:\\n+ anchor_cmd = _anchor_path_cmd(translated_path)\\n+ restore_cmd = _restore_cwd_cmd(session)\\n+ else:\\n+ translated_prev, prev_abs = _translate_path(prev)\\n+ anchor_cmd = f\\\"cd {_q(translated_path)}\\\"\\n+ if prev_abs:\\n+ restore_cmd = _anchor_path_cmd(translated_prev)\\n+ else:\\n+ restore_cmd = (\\n+ f\\\"cd {_q(translated_prev)}\\\"\\n+ if translated_prev\\n+ else _anchor_path_cmd(\\\"\\\")\\n+ )\\n+\\n+ anchor = asyncio.run(_call_execute(anchor_cmd, use_daemon, session=session))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"grep\\\")\\n+ # `-r` preserves the pre-migration recursive default (see unrooted\\n+ # branch above for the full rationale).\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"grep -r {_q(pattern)}\\\", use_daemon, session=session,\\n ))\\n- return result\\n+ asyncio.run(_call_execute(restore_cmd, use_daemon, session=session))\\n+ return _parse_execute_result(op, \\\"grep\\\")\\n \\n \\n-def click(path: str, use_daemon: bool = False) -> dict:\\n+def click(path: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Click an element in the accessibility tree.\\n \\n Args:\\n path: Path to element to click\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with action result\\n \\n Example:\\n- >>> click(\\\"/main/button[0]\\\")\\n- {\\\"action\\\": \\\"click\\\", \\\"path\\\": \\\"/main/button[0]\\\", \\\"status\\\": \\\"success\\\"}\\n+ >>> click(\\\"/main/button[0]\\\", session=session) # required for absolute paths\\n+ {\\\"output\\\": \\\"✓ Clicked\\\\\\\\n[lane: 1]\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_click\\\", {\\\"name\\\": path}, use_daemon))\\n- return result\\n+ translated, is_absolute = _translate_path(path)\\n+ if not translated:\\n+ raise ValueError(\\n+ \\\"click: an element name is required — cannot click the tab root.\\\"\\n+ )\\n+ if is_absolute:\\n+ _require_session_for_split_check(\\\"click\\\", session, use_daemon)\\n+ # Split-and-check: anchor at tab root, halt if anchor fails,\\n+ # otherwise click the relative path, restore. Anchor success is\\n+ # load-bearing — clicking the wrong element if cwd has drifted\\n+ # could trigger an unintended action.\\n+ anchor = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor):\\n+ return _parse_execute_result(anchor, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n+ op = asyncio.run(_call_execute(\\n+ f\\\"click {_q(translated)}\\\", use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(op, \\\"click\\\")\\n \\n \\n-def open_url(url: str, use_daemon: bool = False) -> dict:\\n+def open_url(url: str, use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate to a URL in Chrome.\\n \\n Args:\\n url: URL to navigate to\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure.\\n+\\n+ ``url`` and ``title`` are extracted from the DOMShell response\\n+ text via regex (lines starting ``URL:`` / ``Title:``) — they're\\n+ present when DOMShell emits those lines, omitted otherwise.\\n+ ``page.open_page`` doesn't depend on ``url`` (it always calls\\n+ ``session.set_url(url)`` from the input arg), but the same\\n+ parser is used by ``back`` / ``forward`` whose ``page``-layer\\n+ callers DO depend on ``\\\"url\\\" in result``.\\n \\n Example:\\n >>> open_url(\\\"https://example.com\\\")\\n- {\\\"url\\\": \\\"https://example.com\\\", \\\"status\\\": \\\"loaded\\\"}\\n+ {\\\"output\\\": \\\"✓ Opened\\\\\\\\nURL: https://example.com\\\\\\\\nTitle: Example Domain\\\\\\\\n[lane: 1]\\\",\\n+ \\\"url\\\": \\\"https://example.com\\\",\\n+ \\\"title\\\": \\\"Example Domain\\\"}\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_open\\\", {\\\"url\\\": url}, use_daemon))\\n- return result\\n+ result = asyncio.run(\\n+ _call_execute(f\\\"open {_q(url)}\\\", use_daemon, session=session)\\n+ )\\n+ return _parse_execute_result(result, \\\"open\\\")\\n \\n \\n-def reload(use_daemon: bool = False) -> dict:\\n+def reload(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Reload the current page.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n Dict with reload result\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_reload\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"refresh\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"refresh\\\")\\n \\n \\n-def back(use_daemon: bool = False) -> dict:\\n+def back(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate back in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_back`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_back\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"back\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"back\\\")\\n \\n \\n-def forward(use_daemon: bool = False) -> dict:\\n+def forward(use_daemon: bool = False, *, session: Any = None) -> dict:\\n \\\"\\\"\\\"Navigate forward in history.\\n \\n Args:\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with navigation result\\n+ Dict shaped ``{\\\"output\\\": str, \\\"url\\\": str, \\\"title\\\": str}`` on\\n+ success, or ``{\\\"error\\\": str, \\\"output\\\": str}`` on failure. ``url``\\n+ and ``title`` are extracted from the response text via regex\\n+ (lines starting ``URL:`` / ``Title:``) and may be omitted if\\n+ the response shape changes upstream — ``page.go_forward`` guards\\n+ its ``session.set_url`` update on ``\\\"url\\\" in result``, so a\\n+ missing URL silently skips the update.\\n \\\"\\\"\\\"\\n- result = asyncio.run(_call_tool(\\\"domshell_forward\\\", {}, use_daemon))\\n- return result\\n+ result = asyncio.run(_call_execute(\\\"forward\\\", use_daemon, session=session))\\n+ return _parse_execute_result(result, \\\"forward\\\")\\n \\n \\n-def type_text(path: str, text: str, use_daemon: bool = False) -> dict:\\n+def type_text(\\n+ path: str,\\n+ text: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n+) -> dict:\\n \\\"\\\"\\\"Type text into an input element.\\n \\n- Focuses the element first (via domshell_focus), then types. Both operations\\n- run in a single MCP session so that focus state is preserved.\\n+ Issued as separate ``domshell_execute`` calls — ``focus``, check for\\n+ error, then ``type`` only if ``focus`` succeeded. Both share the\\n+ persisted lane id (via ``session``), so the focus state from the\\n+ first call carries into the second.\\n+\\n+ Why split: DOMShell's multi-line splitter continues past per-line\\n+ errors (apireno/DOMShell#46). That's the right semantic for cleanup\\n+ chains like ``cd / grep / cd back`` (the restore must always run)\\n+ but the WRONG semantic for safety chains like ``focus / type`` — a\\n+ failed ``focus`` followed by a successful ``type`` would dispatch\\n+ keys into whatever was previously focused (potentially a password\\n+ field). Halting between focus and type prevents that.\\n+\\n+ Performance note: in non-daemon mode with an absolute path this\\n+ issues up to four ``_call_execute`` calls (anchor ``cd``, focus,\\n+ type, restore ``cd``), and each opens a fresh stdio MCP session —\\n+ so up to four ``npx`` server spawns per call. Relative paths use\\n+ two calls; daemon mode reuses one persistent connection for the\\n+ whole chain regardless of path form. The per-call overhead is\\n+ accepted to keep the wrapper-level error semantics simple; a future\\n+ refactor could share a single ``ClientSession`` across the chain\\n+ (post-merge follow-up).\\n \\n Args:\\n path: Path to input element\\n text: Text to type\\n use_daemon: Use persistent daemon connection if available\\n+ session: Harness session whose DOMShell lane id is reused / updated\\n \\n Returns:\\n- Dict with action result\\n+ Dict with action result. If ``focus`` errors, returns the focus\\n+ result without calling ``type``.\\n+\\n+ Raises:\\n+ ValueError: If ``path`` or ``text`` contains a newline. DOMShell's\\n+ ``domshell_execute`` treats newlines as command separators, so\\n+ an embedded newline would inject additional commands. Split\\n+ into multiple ``type_text`` calls for multi-line input.\\n \\\"\\\"\\\"\\n- async def _focus_and_type():\\n- global _daemon_session\\n- if use_daemon and _daemon_session is not None:\\n- await _daemon_session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await _daemon_session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n-\\n- server_params = StdioServerParameters(\\n- command=DEFAULT_SERVER_CMD,\\n- args=_build_server_args()\\n+ _assert_single_line(\\\"path\\\", path)\\n+ _assert_single_line(\\\"text\\\", text)\\n+\\n+ # In daemon mode both halves share the persistent `_daemon_session`\\n+ # naturally — same MCP session means same DOMShell lane, no\\n+ # group_id juggling needed. Only the non-daemon path requires\\n+ # `session.domshell_lane_id` because each `_call_execute` opens a\\n+ # fresh stdio session that would land in its own lane otherwise.\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ \\\"type_text: a session argument is required in non-daemon mode \\\"\\n+ \\\"so the focus and type calls share a DOMShell lane via group_id. \\\"\\n+ \\\"(Daemon mode shares the persistent connection's lane \\\"\\n+ \\\"automatically and doesn't need session.)\\\"\\n )\\n- async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- await session.call_tool(\\\"domshell_focus\\\", {\\\"name\\\": path})\\n- return await session.call_tool(\\\"domshell_type\\\", {\\\"text\\\": text})\\n \\n- return asyncio.run(_focus_and_type())\\n+ translated_path, is_absolute = _translate_path(path)\\n+ if not translated_path:\\n+ raise ValueError(\\n+ \\\"type_text: an input path is required — cannot focus the tab root.\\\"\\n+ )\\n+\\n+ # type_text is a safety chain (focus → type), NOT a cleanup-line\\n+ # idiom (cd → op → cd back). Cleanup-line patterns want continue-on-\\n+ # error so the restore always runs. Safety chains want the opposite:\\n+ # halt on the first step's error so the second step doesn't dispatch\\n+ # against stale state. Wrapping focus inside `_wrap_absolute` (a\\n+ # multi-line continue-on-error script) re-introduces the trap the\\n+ # round-4 split was designed to prevent — the anchor's leading \\\"✓\\\"\\n+ # text in the combined response masks the focus error, and `type`\\n+ # would land in whatever was previously focused.\\n+ #\\n+ # So for absolute paths we anchor with a SEPARATE _call_execute\\n+ # (one-line `cd %here%`), check for error, focus as a separate call\\n+ # we can _is_error-check, then type, then restore as a separate\\n+ # best-effort call. All four share the persisted lane via session.\\n+ if is_absolute:\\n+ anchor_result = asyncio.run(_call_execute(\\n+ _anchor_path_cmd(\\\"\\\"), use_daemon, session=session,\\n+ ))\\n+ if _is_error(anchor_result):\\n+ # Anchor failed — we never moved, so no restore is needed.\\n+ return _parse_execute_result(anchor_result, \\\"focus\\\")\\n+\\n+ focus_result = asyncio.run(_call_execute(\\n+ f\\\"focus {_q(translated_path)}\\\", use_daemon, session=session,\\n+ ))\\n+ if _is_error(focus_result):\\n+ # Focus failed — restore cwd before returning so the lane\\n+ # doesn't stay parked at the anchor (only relevant when we\\n+ # actually moved, i.e. the absolute path branch).\\n+ if is_absolute:\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+ return _parse_execute_result(focus_result, \\\"focus\\\")\\n+\\n+ type_result = asyncio.run(_call_execute(\\n+ f\\\"type {_q(text)}\\\", use_daemon, session=session,\\n+ ))\\n+\\n+ if is_absolute:\\n+ # Best-effort restore — type already succeeded, so a restore\\n+ # failure is cosmetic. The next harness cd will correct any\\n+ # drift.\\n+ asyncio.run(_call_execute(\\n+ _restore_cwd_cmd(session), use_daemon, session=session,\\n+ ))\\n+\\n+ return _parse_execute_result(type_result, \\\"type\\\")\\n \\n \\n # ── Daemon control functions ───────────────────────────────────────────\\n\"\n },\n {\n \"comment\": \"The lane marker contract (trailing `[lane: <id>]` line, `shared` sentinel meaning \\\"no isolation\\\") is load-bearing for cross-call state in non-daemon mode but is parsed entirely from string output of a third-party tool. Consider adding a brief comment linking to the DOMShell 2.x docs / release notes where this format is specified, so a future DOMShell change to the marker format (e.g. `[group: ...]` or JSON) leaves a clear trail to the affected code.\",\n \"path\": \"browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\",\n \"hunk\": \"@@ -110,17 +117,252 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\",\n \"resolving_sha\": \"a87647e07ce6af1b3e94d8b4dce8d3b40e760489\",\n \"resolving_diff\": \"diff --git a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\nindex eafc25767b..674f63809d 100644\\n--- a/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n+++ b/browser/agent-harness/cli_anything/browser/utils/domshell_backend.py\\n@@ -10,16 +10,28 @@\\n \\n DOMShell GitHub: https://github.com/apireno/DOMShell\\n Chrome Web Store: https://chromewebstore.google.com/detail/domshell-%E2%80%94-browser-filesy/okcliheamhmijccjknkkplploacoidnp\\n+\\n+DOMShell 2.0.0 (May 2026) changed the default MCP tool surface from 38\\n+per-command tools to a single `domshell_execute` tool that accepts a\\n+shell-style command string (multi-line supported). This wrapper targets\\n+that single tool.\\n \\\"\\\"\\\"\\n \\n import asyncio\\n+import logging\\n import os\\n+import re\\n+import shlex\\n import subprocess\\n import shutil\\n+import threading\\n from typing import Any, Optional\\n from mcp import ClientSession, StdioServerParameters\\n from mcp.client.stdio import stdio_client\\n \\n+\\n+log = logging.getLogger(__name__)\\n+\\n # DOMShell MCP server command\\n # The harness connects to a running DOMShell server via domshell-proxy (stdio bridge).\\n # Configure via environment variables:\\n@@ -51,6 +63,32 @@ def _build_server_args() -> list[str]:\\n _daemon_write: Optional[Any] = None\\n _daemon_client_context: Optional[Any] = None # Store stdio_client context manager\\n \\n+# Module-level lane id captured from the first daemon-mode-no-session\\n+# call. Reused on every subsequent daemon-no-session call so direct\\n+# wrappers like `open_url(use_daemon=True)` followed by\\n+# `ls(use_daemon=True)` preserve browser state across calls, regardless\\n+# of whether the daemon's persistent stdio connection is currently\\n+# alive or whether we've fallen back to spawning a fresh ClientSession\\n+# per call. The captured id is a numeric Chrome tab-group id, which\\n+# persists at the browser level even across MCP session boundaries —\\n+# so a fresh spawn can swapToAgentLane(id) into the lane the previous\\n+# spawn (or a still-living daemon) created.\\n+#\\n+# Stale-lane failure mode: if the user manually closes the Chrome tab\\n+# group this id points to, subsequent calls will surface DOMShell's\\n+# \\\"Error: no lane 'A'\\\" with its own recovery guidance. We don't\\n+# auto-recover here — same shape as `session.domshell_lane_id`\\n+# pointing to a closed group. Restart the daemon (or reset this attr)\\n+# to clear.\\n+_daemon_lane_id: Optional[str] = None\\n+\\n+# Synchronizes the first-call capture of _daemon_lane_id. Concurrent\\n+# callers of _call_execute in daemon mode without a session would\\n+# otherwise race on the `is None` check below. Lock spans only the\\n+# check + assignment (microsecond contention), not the MCP call.\\n+# (Copilot R4 on commit 5790651.)\\n+_daemon_lane_lock = threading.Lock()\\n+\\n \\n def _check_npx() -> bool:\\n \\\"\\\"\\\"Check if npx is available.\\\"\\\"\\\"\\n@@ -78,7 +116,7 @@ def is_available() -> tuple[bool, str]:\\n \\n Examples:\\n >>> is_available()\\n- (True, \\\"DOMShell v1.0.0 is available\\\")\\n+ (True, \\\"DOMShell vX.Y.Z is available\\\") # whatever npx resolves to\\n >>> is_available()\\n (False, \\\"npx not found. Install Node.js from https://nodejs.org/\\\")\\n \\\"\\\"\\\"\\n@@ -110,17 +148,374 @@ def is_available() -> tuple[bool, str]:\\n return False, f\\\"DOMShell check failed: {e}\\\"\\n \\n \\n-async def _call_tool(\\n- tool_name: str,\\n- arguments: dict,\\n- use_daemon: bool = False\\n+def _q(arg: str) -> str:\\n+ \\\"\\\"\\\"Quote an argument for the DOMShell command parser (shell-style).\\n+\\n+ Rejects newlines: DOMShell's ``domshell_execute`` splits multi-line\\n+ input *before* shell-style quote parsing, so a ``\\\\\\\\n`` or ``\\\\\\\\r``\\n+ inside an otherwise-quoted argument still becomes a command\\n+ separator. Enforcing the check here means every wrapper that flows\\n+ user input through ``_q`` is protected by default, instead of\\n+ relying on per-call ``_assert_single_line`` at each call site.\\n+\\n+ Wrappers may still call ``_assert_single_line`` ahead of ``_q`` when a\\n+ field-named error message (e.g. ``\\\"text: ...\\\"``) is more useful than\\n+ the generic one raised here.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in arg or \\\"\\\\r\\\" in arg:\\n+ # Bound the echoed value so an arbitrarily large untrusted payload\\n+ # (e.g. a multi-line paste from the page) doesn't end up verbatim\\n+ # in error messages or downstream logs / telemetry.\\n+ preview = arg[:80] + (\\\"…\\\" if len(arg) > 80 else \\\"\\\")\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in command arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ \\\"so a newline inside any wrapper input would inject additional \\\"\\n+ f\\\"commands. Got ({len(arg)} chars): {preview!r}\\\"\\n+ )\\n+ return shlex.quote(arg)\\n+\\n+\\n+# DOMShell 2.x appends a \\\"[lane: <id>]\\\" marker as the last line of every\\n+# domshell_execute reply. We parse it out and store it on the harness\\n+# Session so subsequent calls can pass group_id=<id> and stay pinned to\\n+# the same Chrome tab-group (i.e. same browser state).\\n+#\\n+# The marker format is part of the DOMShell 2.x wire contract — see the\\n+# upstream docs (https://github.com/apireno/DOMShell, search the README\\n+# for \\\"Multi-line semantics\\\" / \\\"lane marker\\\"). If DOMShell ever changes\\n+# the marker format (e.g. to JSON, or to [group: …]), this regex needs\\n+# to follow.\\n+_LANE_LINE = re.compile(r\\\"\\\\[lane:\\\\s*([^\\\\]\\\\s]+)\\\\s*\\\\]\\\\s*$\\\")\\n+\\n+\\n+def _extract_lane_id(result: Any) -> Optional[str]:\\n+ \\\"\\\"\\\"Parse the trailing ``[lane: <id>]`` marker DOMShell appends to replies.\\n+\\n+ Returns the lane id, or ``None`` if no marker is present, the text is\\n+ empty, or the marker reports the default \\\"shared\\\" lane (which is\\n+ DOMShell's no-isolation sentinel and not something we want to pin to).\\n+ \\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ if not text:\\n+ return None\\n+ m = _LANE_LINE.search(text.strip())\\n+ if not m:\\n+ return None\\n+ lane = m.group(1).strip()\\n+ if not lane or lane == \\\"shared\\\":\\n+ return None\\n+ return lane\\n+\\n+\\n+def _capture_lane(session: Any, result: Any) -> None:\\n+ \\\"\\\"\\\"Update ``session.domshell_lane_id`` from a ``_call_execute`` result.\\\"\\\"\\\"\\n+ if session is None:\\n+ return\\n+ lane = _extract_lane_id(result)\\n+ if lane:\\n+ session.domshell_lane_id = lane\\n+\\n+\\n+def _translate_path(harness_path: str) -> tuple[str, bool]:\\n+ \\\"\\\"\\\"Translate a harness DOM path into ``(stripped, is_absolute)``.\\n+\\n+ The harness models ``/`` as the focused tab's AX root. DOMShell models\\n+ ``/`` and ``~/`` as the BROWSER root (windows/tabs). DOMShell also\\n+ keeps a per-lane cwd that persists between commands — so after\\n+ ``fs cd /main`` the lane cwd is no longer the tab root, and a\\n+ subsequent ``ls main`` (the naive strip-one-slash form) would resolve\\n+ against the drifted cwd as ``/main/main``. Wrong target.\\n+\\n+ The fix: distinguish *absolute* from *relative* harness paths so\\n+ callers can wrap the operation in ``cd %here%[/deeper]\\\\\\\\n<op>\\\\\\\\ncd\\n+ <restore>`` for the absolute case (anchoring at the tab root), and\\n+ pass relative paths through unchanged (the lane cwd is the right\\n+ reference for them).\\n+\\n+ Uses ``lstrip(\\\"/\\\")`` so accidental ``//main`` collapses to ``main``.\\n+\\n+ Examples:\\n+ ``\\\"\\\"`` → ``(\\\"\\\", False)``\\n+ ``\\\"/\\\"`` → ``(\\\"\\\", True)``\\n+ ``\\\"/main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"//main\\\"`` → ``(\\\"main\\\", True)``\\n+ ``\\\"/main/btn\\\"`` → ``(\\\"main/btn\\\", True)``\\n+ ``\\\"main\\\"`` → ``(\\\"main\\\", False)``\\n+ ``\\\"..\\\"`` → ``(\\\"..\\\", False)``\\n+ \\\"\\\"\\\"\\n+ # Newline guard at the translation boundary: absolute-path branches\\n+ # interpolate `%here%/<translated>` without going through `_q`\\n+ # (DOMShell's path-variable expander runs before quote parsing on\\n+ # `cd`, so quoting would defeat it). Catching newlines here means\\n+ # every wrapper that consumes the translated path is protected\\n+ # against injection, even if the wrapper skips `_q`.\\n+ if \\\"\\\\n\\\" in harness_path or \\\"\\\\r\\\" in harness_path:\\n+ raise ValueError(\\n+ \\\"Newline characters are not allowed in path arguments — \\\"\\n+ \\\"DOMShell's domshell_execute treats them as command separators, \\\"\\n+ f\\\"so a newline in a path would inject additional commands. \\\"\\n+ f\\\"Got ({len(harness_path)} chars): \\\"\\n+ f\\\"{(harness_path[:80] + ('…' if len(harness_path) > 80 else ''))!r}\\\"\\n+ )\\n+ if not harness_path:\\n+ return \\\"\\\", False\\n+ if harness_path.startswith(\\\"/\\\"):\\n+ return harness_path.lstrip(\\\"/\\\"), True\\n+ return harness_path, False\\n+\\n+\\n+def _here_path(deeper: str) -> str:\\n+ \\\"\\\"\\\"Build a ``%here%[/<deeper>]`` token, shell-quoted as a single unit.\\n+\\n+ DOMShell's ``cd`` accepts quoted ``%here%`` cleanly\\n+ (``cd '%here%/main'`` was upstream-smoked: ``✓ Entered tab …``), so\\n+ we quote uniformly via ``_q``. Whitespace, brackets, ``$`` etc. in\\n+ the ``<deeper>`` portion survive the wrap correctly.\\n+\\n+ For simple cases (no shell metacharacters) ``_q`` returns the input\\n+ unchanged, so ``_here_path(\\\"main\\\")`` is still ``%here%/main``.\\n+ \\\"\\\"\\\"\\n+ return _q(f\\\"%here%/{deeper}\\\") if deeper else _q(\\\"%here%\\\")\\n+\\n+\\n+def _restore_cwd_cmd(session: Any) -> str:\\n+ \\\"\\\"\\\"Build the trailing ``cd <wd>`` line for an absolute-path wrap.\\n+\\n+ Uses the harness's tracked ``working_dir`` (translated to DOMShell\\n+ form) so after the wrapped operation the lane's cwd matches what the\\n+ harness thinks it is. Without this restore, a wrapped operation\\n+ against ``/`` would leave the lane parked at ``%here%`` even though\\n+ the harness's ``working_dir`` is something like ``/main``.\\n+\\n+ The harness ``working_dir`` is always absolute in normal use, so the\\n+ common output shape is ``cd %here%/<stripped>``. The relative\\n+ branch is a defensive fallback for an unusual session shape.\\n+ \\\"\\\"\\\"\\n+ wd = getattr(session, \\\"working_dir\\\", None) or \\\"/\\\"\\n+ stripped, is_abs = _translate_path(wd)\\n+ if is_abs:\\n+ return f\\\"cd {_here_path(stripped)}\\\"\\n+ return f\\\"cd {_q(stripped)}\\\" if stripped else f\\\"cd {_here_path('')}\\\"\\n+\\n+\\n+def _anchor_path_cmd(deeper: str = \\\"\\\") -> str:\\n+ \\\"\\\"\\\"Build a single ``cd %here%[/<deeper>]`` command line, shell-quoted.\\n+\\n+ The reusable anchor primitive for split-and-check wrapper patterns.\\n+ Every absolute-path wrapper (ls/cat/click/grep) issues this as its\\n+ first ``_call_execute``, then ``_is_error``-checks the result before\\n+ running the operation. Used for the anchor and restore positions in\\n+ the split-and-check pattern.\\n+ \\\"\\\"\\\"\\n+ return f\\\"cd {_here_path(deeper)}\\\"\\n+\\n+\\n+def _require_session_for_split_check(\\n+ wrapper: str, session: Any, use_daemon: bool,\\n+) -> None:\\n+ \\\"\\\"\\\"Raise if a split-and-check wrapper would lose lane consistency.\\n+\\n+ Split-and-check patterns (anchor → op → restore as separate\\n+ ``_call_execute`` calls) need all three calls in the same DOMShell\\n+ lane. In daemon mode the persistent connection guarantees that\\n+ naturally; otherwise the wrapper needs ``session.domshell_lane_id``\\n+ to forward via ``group_id`` on each call. Without either, the\\n+ anchor lands in lane A and the operation lands in lane B — same\\n+ lane-isolation regression as round-5's first failure mode.\\n+\\n+ The general rule: any wrapper that issues multiple\\n+ ``_call_execute`` calls whose correctness depends on shared lane\\n+ state requires a session in non-daemon mode. Mirrors the round-6.1\\n+ guard in ``type_text``; applied to ``ls`` / ``cat`` / ``click``\\n+ absolute paths and ``grep`` rooted paths (both absolute and\\n+ relative) in round 7.2. Centralizes the contract so future\\n+ multi-call wrappers can call into the same check.\\n+ \\\"\\\"\\\"\\n+ if session is None and not use_daemon:\\n+ raise ValueError(\\n+ f\\\"{wrapper}: a session argument is required in non-daemon \\\"\\n+ \\\"mode for rooted paths so the anchor cd and the operation \\\"\\n+ \\\"share a DOMShell lane. Either pass a Session, use an \\\"\\n+ \\\"unrooted form, or enable daemon mode.\\\"\\n+ )\\n+\\n+\\n+# CSI (ANSI) escape sequences DOMShell wraps error text in (typically red).\\n+# Strip them before prefix-matching \\\"error\\\" so an ANSI-coloured error line\\n+# isn't misread as success.\\n+_ANSI_CSI_RE = re.compile(r\\\"\\\\x1b\\\\[[0-9;]*[A-Za-z]\\\")\\n+\\n+\\n+def _is_error(result: Any) -> bool:\\n+ \\\"\\\"\\\"Detect whether a ``domshell_execute`` result represents an error.\\n+\\n+ DOMShell's actual error shape (verified upstream) is ANSI-red-wrapped\\n+ AND command-prefixed, e.g.:\\n+\\n+ * ``\\\\\\\\x1b[31mcd: foo: No such directory\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mfocus: No such element\\\\\\\\x1b[0m``\\n+ * ``\\\\\\\\x1b[31mls: main: No such directory\\\\\\\\x1b[0m``\\n+\\n+ Note none of these start with the literal \\\"error\\\" — the earlier\\n+ detection that ANSI-stripped first then checked ``startswith(\\\"error\\\")``\\n+ silently failed every command-prefixed case, which silently regressed\\n+ the safety chain across ``ls`` / ``cat`` / ``click`` / ``grep`` /\\n+ ``type_text`` (Codex PR #308 round 7+). The fix: detect the\\n+ ``\\\\\\\\x1b[31m`` red color marker BEFORE ANSI stripping — DOMShell wraps\\n+ every error in red and uses different codes (e.g. ``\\\\\\\\x1b[32m``\\n+ green) for success.\\n+\\n+ Inspects ``isError`` and dict ``error``/``isError`` keys first\\n+ (covers the MCP SDK's explicit error flag and dict test fixtures),\\n+ then the ANSI-red marker, with a final fallback to a stripped\\n+ ``Error:`` prefix for any input that has been pre-stripped (e.g. by\\n+ a transport layer) or that arrives without DOMShell's coloring.\\n+ \\\"\\\"\\\"\\n+ if hasattr(result, \\\"isError\\\") and result.isError:\\n+ return True\\n+ if isinstance(result, dict):\\n+ if result.get(\\\"isError\\\") or result.get(\\\"error\\\"):\\n+ return True\\n+\\n+ text = _extract_text(result)\\n+ if not text:\\n+ return False\\n+\\n+ # DOMShell wraps errors in ANSI red. Detect BEFORE stripping; the\\n+ # color code IS the signal, and the message that follows is\\n+ # typically command-prefixed (cd: …, focus: …, ls: …) rather than\\n+ # \\\"Error:\\\"-prefixed.\\n+ if \\\"\\\\x1b[31m\\\" in text:\\n+ return True\\n+\\n+ # Fallback: ANSI-stripped text with explicit \\\"Error:\\\" prefix.\\n+ # Catches rarer non-colored errors and any input that arrives\\n+ # pre-stripped.\\n+ cleaned = _ANSI_CSI_RE.sub(\\\"\\\", text).strip().lower()\\n+ if cleaned.startswith(\\\"error:\\\"):\\n+ return True\\n+\\n+ return False\\n+\\n+\\n+def _extract_text(result: Any) -> str:\\n+ \\\"\\\"\\\"Concatenate ``content[*].text`` from a CallToolResult-like object.\\\"\\\"\\\"\\n+ text = \\\"\\\"\\n+ content = getattr(result, \\\"content\\\", None)\\n+ if content:\\n+ for c in content:\\n+ piece = getattr(c, \\\"text\\\", None)\\n+ if piece:\\n+ text += piece\\n+ return text\\n+\\n+\\n+def _parse_execute_result(result: Any, command: str) -> dict:\\n+ \\\"\\\"\\\"Translate a ``domshell_execute`` text response into the dict shape\\n+ ``browser_cli.py`` and friends consume.\\n+\\n+ DOMShell 2.x returns text content over MCP (plus a trailing\\n+ ``[lane: <id>]`` marker). The CLI was written for the pre-2.0\\n+ per-command tools, which returned structured dicts — so without\\n+ this translator the harness throws ``AttributeError`` on\\n+ ``result.get(\\\"entries\\\")`` / ``result.get(\\\"matches\\\")`` etc.\\n+\\n+ The shape contract per command (read off the CLI callers):\\n+\\n+ * ``ls`` → ``{\\\"entries\\\": [{\\\"name\\\", \\\"role\\\", \\\"path\\\"}, ...], \\\"raw\\\"}``\\n+ * ``grep``→ ``{\\\"matches\\\": [...], \\\"raw\\\"}``\\n+ * error → ``{\\\"error\\\": text, \\\"output\\\": text}`` (caller checks\\n+ ``\\\"error\\\" in result`` before normal handling)\\n+ * other → ``{\\\"output\\\": text}`` (CLI's ``output()`` / ``_print_dict``\\n+ handles arbitrary dicts; ``page.go_back/forward`` skip the\\n+ ``set_url`` step if ``\\\"url\\\"`` is absent, matching today's behavior)\\n+\\n+ This is a minimum-viable parser that satisfies the dict-key\\n+ contract. Finer-grained parsing of element name / role / path\\n+ columns can land as a follow-up once DOMShell's exact text format\\n+ stabilizes — for now every line is plumbed through as the ``name``\\n+ field (and the ``path`` field) so the CLI's table view still\\n+ renders rather than crashing.\\n+ \\\"\\\"\\\"\\n+ text = _LANE_LINE.sub(\\\"\\\", _extract_text(result)).strip()\\n+\\n+ if _is_error(result):\\n+ return {\\\"error\\\": text, \\\"output\\\": text}\\n+\\n+ if command == \\\"ls\\\":\\n+ lines = [ln for ln in text.splitlines() if ln.strip()]\\n+ entries = [\\n+ {\\\"name\\\": ln.strip(), \\\"role\\\": \\\"\\\", \\\"path\\\": ln.strip()}\\n+ for ln in lines\\n+ ]\\n+ return {\\\"entries\\\": entries, \\\"raw\\\": text}\\n+\\n+ if command == \\\"grep\\\":\\n+ matches = [ln for ln in text.splitlines() if ln.strip()]\\n+ return {\\\"matches\\\": matches, \\\"raw\\\": text}\\n+\\n+ if command in (\\\"back\\\", \\\"forward\\\", \\\"navigate\\\", \\\"open\\\"):\\n+ # Navigation commands typically respond with a `URL: <url>`\\n+ # (and often `Title: <title>`) line — extract both so\\n+ # `page.go_back` / `page.go_forward`'s `\\\"url\\\" in result` guards\\n+ # actually fire and `session.set_url` updates correctly. (Round\\n+ # 7's parser made these guards permanently False; this is the\\n+ # Codex P2 #1 fix.) The raw `output` is preserved alongside so\\n+ # CLI display paths still work.\\n+ nav: dict = {\\\"output\\\": text}\\n+ url_match = re.search(r\\\"URL:\\\\s+(\\\\S+)\\\", text)\\n+ if url_match:\\n+ nav[\\\"url\\\"] = url_match.group(1)\\n+ title_match = re.search(r\\\"Title:\\\\s+(.+?)(?:\\\\r?\\\\n|$)\\\", text)\\n+ if title_match:\\n+ nav[\\\"title\\\"] = title_match.group(1).strip()\\n+ return nav\\n+\\n+ # cd / cat / click / focus / type / refresh all funnel through the\\n+ # CLI's generic dict pretty-printer; an ``{\\\"output\\\": text}`` shape\\n+ # is enough.\\n+ return {\\\"output\\\": text}\\n+\\n+\\n+def _assert_single_line(field: str, value: str) -> None:\\n+ \\\"\\\"\\\"Reject newline characters in a user-supplied string.\\n+\\n+ DOMShell's ``domshell_execute`` splits its ``command`` argument on\\n+ newlines *before* shell-style quote parsing, so a literal ``\\\\\\\\n`` or\\n+ ``\\\\\\\\r`` inside an otherwise-quoted argument escapes the quoting and\\n+ starts a fresh DOMShell command. Guard at the wrapper layer for any\\n+ value that gets interpolated into a multi-line command string.\\n+ \\\"\\\"\\\"\\n+ if \\\"\\\\n\\\" in value or \\\"\\\\r\\\" in value:\\n+ raise ValueError(\\n+ f\\\"{field}: newline characters are not allowed (would be interpreted \\\"\\n+ f\\\"as DOMShell command separators). Got: {value!r}\\\"\\n+ )\\n+\\n+\\n+async def _call_execute(\\n+ command: str,\\n+ use_daemon: bool = False,\\n+ *,\\n+ session: Any = None,\\n ) -> Any:\\n- \\\"\\\"\\\"Call a DOMShell MCP tool.\\n+ \\\"\\\"\\\"Run a DOMShell command via the single `domshell_execute` MCP tool.\\n \\n Args:\\n- tool_name: Name of the MCP tool (e.g., \\\"domshell_ls\\\", \\\"domshell_cd\\\")\\n- arguments: Arguments to pass to the tool\\n+ command: DOMShell command string. May contain newlines for multi-command\\n+ execution — each line runs in order in the same shell state.\\n use_daemon: If True, use persistent daemon connection (if available)\\n+ session: Harness ``Session`` whose ``domshell_lane_id`` should be\\n+ forwarded as ``group_id`` (when set) and updated from the result\\n+ (when DOMShell returns a ``[lane: <id>]`` marker). Pass ``None``\\n+ for one-off direct calls that don't need cross-call state.\\n \\n Returns:\\n Tool result as returned by MCP server\\n@@ -128,15 +523,61 @@ async def _call_tool(\\n Raises:\\n RuntimeError: If MCP server is not available or tool call fails\\n \\\"\\\"\\\"\\n- global _daemon_session, _daemon_read, _daemon_write\\n+ global _daemon_session, _daemon_read, _daemon_write, _daemon_lane_id\\n+\\n+ arguments: dict[str, Any] = {\\\"command\\\": command}\\n+ # Lane handling — three sources, in priority order:\\n+ # • Session with a captured lane id → reuse that lane (REPL pattern,\\n+ # state preserved across non-daemon spawn-per-call sequences).\\n+ # • Daemon mode + no session + previously captured _daemon_lane_id\\n+ # → reuse the daemon-level captured id. Works whether the daemon's\\n+ # stdio is alive (id reused on persistent connection) or dead\\n+ # (fresh spawn joins the existing Chrome tab-group by id).\\n+ # • Otherwise → group_id=\\\"new\\\". DOMShell creates a fresh isolated\\n+ # lane and returns the id in the [lane: ...] marker, captured into\\n+ # either session.domshell_lane_id or _daemon_lane_id for next time.\\n+ #\\n+ # The \\\"shared\\\" branch from the previous version of this code (commit\\n+ # 99d1182) is gone. It claimed the per-connection default lane stayed\\n+ # sticky across calls — true when the persistent daemon connection is\\n+ # alive, but a lie in the fall-back spawn path where each call gets a\\n+ # different per-MCP-session default lane. @yuh-yang's review of\\n+ # b684732 flagged the inconsistency. The module-level capture path\\n+ # below is consistent across both daemon-alive and daemon-dead.\\n+ if session is not None and getattr(session, \\\"domshell_lane_id\\\", None):\\n+ arguments[\\\"group_id\\\"] = session.domshell_lane_id\\n+ elif use_daemon and _daemon_lane_id:\\n+ arguments[\\\"group_id\\\"] = _daemon_lane_id\\n+ else:\\n+ arguments[\\\"group_id\\\"] = \\\"new\\\"\\n \\n if use_daemon and _daemon_session is not None:\\n # Use persistent daemon connection\\n try:\\n- result = await _daemon_session.call_tool(tool_name, arguments)\\n+ result = await _daemon_session.call_tool(\\n+ \\\"domshell_execute\\\", arguments\\n+ )\\n+ _capture_lane(session, result)\\n+ # Daemon-level capture on first daemon-no-session call so\\n+ # subsequent calls reuse the same lane regardless of whether\\n+ # the daemon stays alive or we fall back to fresh spawns.\\n+ # `is None` check moved INSIDE the lock to fix the\\n+ # test-and-set race between concurrent callers.\\n+ if use_daemon and session is None:\\n+ with _daemon_lane_lock:\\n+ if _daemon_lane_id is None:\\n+ captured = _extract_lane_id(result)\\n+ if captured:\\n+ _daemon_lane_id = captured\\n return result\\n except Exception as e:\\n- # Daemon died, fall back to spawning new server\\n+ # Daemon died — log diagnosability and fall back to spawning\\n+ # a fresh server below. Silent swallow was making the daemon\\n+ # failure mode invisible in user reports.\\n+ log.warning(\\n+ \\\"DOMShell daemon call failed, respawning per-command: %s\\\", e,\\n+ exc_info=True,\\n+ )\\n await _stop_daemon()\\n \\n # Spawn new MCP server process\\n@@ -147,9 +588,21 @@ async def _call_tool(\\n \\n try:\\n async with stdio_client(server_params) as (read, write):\\n- async with ClientSession(read, write) as session:\\n- await session.initialize()\\n- result = await session.call_tool(tool_name, arguments)\\n+ async with ClientSession(read, write) as mcp_session:\\n+ await mcp_session.initialize()\\n+ result = await mcp_session.call_tool(\\n+ \\\"domshell_execute\\\"